diff --git a/src/main/java/com/android/tools/r8/Version.java b/src/main/java/com/android/tools/r8/Version.java
index 6f062cf..5a0d2c4 100644
--- a/src/main/java/com/android/tools/r8/Version.java
+++ b/src/main/java/com/android/tools/r8/Version.java
@@ -11,7 +11,7 @@
 
   // This field is accessed from release scripts using simple pattern matching.
   // Therefore, changing this field could break our release scripts.
-  public static final String LABEL = "v1.2.4-dev";
+  public static final String LABEL = "v1.2.6-dev";
 
   private Version() {
   }
diff --git a/src/main/java/com/android/tools/r8/cf/CfPrinter.java b/src/main/java/com/android/tools/r8/cf/CfPrinter.java
index 39d916a..181ebac 100644
--- a/src/main/java/com/android/tools/r8/cf/CfPrinter.java
+++ b/src/main/java/com/android/tools/r8/cf/CfPrinter.java
@@ -16,6 +16,9 @@
 import com.android.tools.r8.cf.code.CfConstString;
 import com.android.tools.r8.cf.code.CfFieldInstruction;
 import com.android.tools.r8.cf.code.CfFrame;
+import com.android.tools.r8.cf.code.CfFrame.Uninitialized;
+import com.android.tools.r8.cf.code.CfFrame.UninitializedNew;
+import com.android.tools.r8.cf.code.CfFrame.UninitializedThis;
 import com.android.tools.r8.cf.code.CfGoto;
 import com.android.tools.r8.cf.code.CfIf;
 import com.android.tools.r8.cf.code.CfIfCmp;
@@ -240,7 +243,17 @@
     StringBuilder builder = new StringBuilder("frame: [");
     String separator = "";
     for (Entry<DexType> entry : frame.getLocals().int2ReferenceEntrySet()) {
-      builder.append(separator).append(entry.getIntKey()).append(':').append(entry.getValue());
+      builder.append(separator).append(entry.getIntKey()).append(':');
+      Uninitialized allocator = frame.getAllocators().get(entry.getIntKey());
+      if (allocator == null) {
+        builder.append(entry.getValue());
+      } else if (allocator instanceof UninitializedThis) {
+        builder.append("uninitialized this");
+      } else {
+        builder
+            .append("uninitialized ")
+            .append(getLabel(((UninitializedNew) allocator).getLabel()));
+      }
       separator = ", ";
     }
     builder.append("] ");
diff --git a/src/main/java/com/android/tools/r8/cf/code/CfFrame.java b/src/main/java/com/android/tools/r8/cf/code/CfFrame.java
index 2818e44..b5e759c 100644
--- a/src/main/java/com/android/tools/r8/cf/code/CfFrame.java
+++ b/src/main/java/com/android/tools/r8/cf/code/CfFrame.java
@@ -17,11 +17,44 @@
 
 public class CfFrame extends CfInstruction {
 
+  public abstract static class Uninitialized {
+    abstract Object getAsmLabel();
+  }
+
+  public static class UninitializedNew extends Uninitialized {
+    private final CfLabel label;
+
+    public UninitializedNew(CfLabel label) {
+      this.label = label;
+    }
+
+    @Override
+    Object getAsmLabel() {
+      return label.getLabel();
+    }
+
+    public CfLabel getLabel() {
+      return label;
+    }
+  }
+
+  public static class UninitializedThis extends Uninitialized {
+    @Override
+    Object getAsmLabel() {
+      return Opcodes.UNINITIALIZED_THIS;
+    }
+  }
+
   private final Int2ReferenceSortedMap<DexType> locals;
+  private final Int2ReferenceSortedMap<Uninitialized> allocators;
   private final List<DexType> stack;
 
-  public CfFrame(Int2ReferenceSortedMap<DexType> locals, List<DexType> stack) {
+  public CfFrame(
+      Int2ReferenceSortedMap<DexType> locals,
+      Int2ReferenceSortedMap<Uninitialized> allocators,
+      List<DexType> stack) {
     this.locals = locals;
+    this.allocators = allocators;
     this.stack = stack;
   }
 
@@ -29,6 +62,10 @@
     return locals;
   }
 
+  public Int2ReferenceSortedMap<Uninitialized> getAllocators() {
+    return allocators;
+  }
+
   public List<DexType> getStack() {
     return stack;
   }
@@ -88,7 +125,8 @@
     int localIndex = 0;
     for (int i = 0; i <= maxRegister; i++) {
       DexType type = locals.get(i);
-      Object typeOpcode = getType(type, lens);
+      Uninitialized allocator = allocators.get(i);
+      Object typeOpcode = allocator == null ? getType(type, lens) : allocator.getAsmLabel();
       localsTypes[localIndex++] = typeOpcode;
       if (type != null && isWide(type)) {
         i++;
diff --git a/src/main/java/com/android/tools/r8/cf/code/CfInvokeDynamic.java b/src/main/java/com/android/tools/r8/cf/code/CfInvokeDynamic.java
index a681943..f830427 100644
--- a/src/main/java/com/android/tools/r8/cf/code/CfInvokeDynamic.java
+++ b/src/main/java/com/android/tools/r8/cf/code/CfInvokeDynamic.java
@@ -46,8 +46,8 @@
     DexString methodName;
     if (lens.isIdentityLens()) {
       methodName = callSite.methodName;
-    } else if (callSite.interfaceMethod != null) {
-      methodName = lens.lookupName(callSite.interfaceMethod);
+    } else if (!callSite.interfaceMethods.isEmpty()) {
+      methodName = lens.lookupName(callSite.interfaceMethods.get(0));
     } else {
       throw new Unimplemented("Minification of non-lambda InvokeDynamic not supported");
     }
diff --git a/src/main/java/com/android/tools/r8/dexsplitter/DexSplitter.java b/src/main/java/com/android/tools/r8/dexsplitter/DexSplitter.java
index 45a62ef..e3753a7 100644
--- a/src/main/java/com/android/tools/r8/dexsplitter/DexSplitter.java
+++ b/src/main/java/com/android/tools/r8/dexsplitter/DexSplitter.java
@@ -14,6 +14,7 @@
 import com.android.tools.r8.utils.FeatureClassMapping.FeatureMappingException;
 import com.android.tools.r8.utils.OptionsParsing;
 import com.android.tools.r8.utils.OptionsParsing.ParseContext;
+import com.google.common.collect.ImmutableList;
 import java.io.IOException;
 import java.nio.file.Paths;
 import java.util.ArrayList;
@@ -27,40 +28,80 @@
   private static final boolean PRINT_ARGS = false;
 
   public static class Options {
-    List<String> inputArchives = new ArrayList<>();
-    List<String> featureJars = new ArrayList<>();
-    String splitBaseName = DEFAULT_OUTPUT_ARCHIVE_FILENAME;
-    String featureSplitMapping;
-    String proguardMap;
+    private List<String> inputArchives = new ArrayList<>();
+    private List<String> featureJars = new ArrayList<>();
+    private String splitBaseName = DEFAULT_OUTPUT_ARCHIVE_FILENAME;
+    private String featureSplitMapping;
+    private String proguardMap;
+
+    public String getSplitBaseName() {
+      return splitBaseName;
+    }
+
+    public void setSplitBaseName(String splitBaseName) {
+      this.splitBaseName = splitBaseName;
+    }
+
+    public String getFeatureSplitMapping() {
+      return featureSplitMapping;
+    }
+
+    public void setFeatureSplitMapping(String featureSplitMapping) {
+      this.featureSplitMapping = featureSplitMapping;
+    }
+
+    public String getProguardMap() {
+      return proguardMap;
+    }
+
+    public void setProguardMap(String proguardMap) {
+      this.proguardMap = proguardMap;
+    }
+
+    public void addInputArchive(String inputArchive) {
+      inputArchives.add(inputArchive);
+    }
+
+    public void addFeatureJar(String featureJar) {
+      featureJars.add(featureJar);
+    }
+
+    public ImmutableList<String> getInputArchives() {
+      return ImmutableList.copyOf(inputArchives);
+    }
+
+    public ImmutableList<String> getFeatureJars() {
+      return ImmutableList.copyOf(featureJars);
+    }
   }
 
   private static Options parseArguments(String[] args) throws IOException {
     Options options = new Options();
     ParseContext context = new ParseContext(args);
     while (context.head() != null) {
-      List<String> input = OptionsParsing.tryParseMulti(context, "--input");
-      if (input != null) {
-        options.inputArchives.addAll(input);
+      List<String> inputs = OptionsParsing.tryParseMulti(context, "--input");
+      if (inputs != null) {
+        inputs.stream().forEach(options::addInputArchive);
         continue;
       }
       List<String> featureJars = OptionsParsing.tryParseMulti(context, "--feature-jar");
       if (featureJars != null) {
-        options.featureJars.addAll(featureJars);
+        featureJars.stream().forEach(options::addFeatureJar);
         continue;
       }
       String output = OptionsParsing.tryParseSingle(context, "--output", "-o");
       if (output != null) {
-        options.splitBaseName = output;
+        options.setSplitBaseName(output);
         continue;
       }
       String proguardMap = OptionsParsing.tryParseSingle(context, "--proguard-map", null);
       if (proguardMap != null) {
-        options.proguardMap = proguardMap;
+        options.setProguardMap(proguardMap);
         continue;
       }
       String featureSplit = OptionsParsing.tryParseSingle(context, "--feature-splits", null);
       if (featureSplit != null) {
-        options.featureSplitMapping = featureSplit;
+        options.setFeatureSplitMapping(featureSplit);
         continue;
       }
       throw new RuntimeException(String.format("Unknown options: '%s'.", context.head()));
@@ -70,8 +111,8 @@
 
   private static FeatureClassMapping createFeatureClassMapping(Options options)
       throws IOException, FeatureMappingException, ResourceException {
-    if (options.featureSplitMapping != null) {
-      return FeatureClassMapping.fromSpecification(Paths.get(options.featureSplitMapping));
+    if (options.getFeatureSplitMapping() != null) {
+      return FeatureClassMapping.fromSpecification(Paths.get(options.getFeatureSplitMapping()));
     }
     assert !options.featureJars.isEmpty();
     return FeatureClassMapping.fromJarFiles(options.featureJars);
@@ -87,13 +128,13 @@
   public static void run(Options options)
       throws IOException, FeatureMappingException, ResourceException, CompilationException,
       ExecutionException, CompilationFailedException {
-    if (options.inputArchives.isEmpty()) {
+    if (options.getInputArchives().isEmpty()) {
       throw new RuntimeException("Need at least one --input");
     }
-    if (options.featureSplitMapping == null && options.featureJars.isEmpty()) {
+    if (options.getFeatureSplitMapping() == null && options.getFeatureJars().isEmpty()) {
       throw new RuntimeException("You must supply a feature split mapping or feature jars");
     }
-    if (options.featureSplitMapping != null && !options.featureJars.isEmpty()) {
+    if (options.getFeatureSplitMapping() != null && !options.getFeatureJars().isEmpty()) {
       throw new RuntimeException("You can't supply both a feature split mapping and feature jars");
     }
 
@@ -108,7 +149,7 @@
     FeatureClassMapping featureClassMapping = createFeatureClassMapping(options);
 
     DexSplitterHelper.run(
-        builder.build(), featureClassMapping, options.splitBaseName, options.proguardMap);
+        builder.build(), featureClassMapping, options.getSplitBaseName(), options.getProguardMap());
   }
 
   public static void main(String[] args) {
diff --git a/src/main/java/com/android/tools/r8/graph/DexCallSite.java b/src/main/java/com/android/tools/r8/graph/DexCallSite.java
index 9e22713..ac954f8 100644
--- a/src/main/java/com/android/tools/r8/graph/DexCallSite.java
+++ b/src/main/java/com/android/tools/r8/graph/DexCallSite.java
@@ -29,22 +29,27 @@
   public final DexMethodHandle bootstrapMethod;
   public final List<DexValue> bootstrapArgs;
 
-  public final DexMethod interfaceMethod;
+  public final List<DexMethod> interfaceMethods;
 
   private DexEncodedArray encodedArray = null;
 
-  DexCallSite(DexString methodName, DexProto methodProto,
-      DexMethodHandle bootstrapMethod, List<DexValue> bootstrapArgs, DexMethod interfaceMethod) {
+  DexCallSite(
+      DexString methodName,
+      DexProto methodProto,
+      DexMethodHandle bootstrapMethod,
+      List<DexValue> bootstrapArgs,
+      List<DexMethod> interfaceMethods) {
     assert methodName != null;
     assert methodProto != null;
     assert bootstrapMethod != null;
     assert bootstrapArgs != null;
+    assert interfaceMethods != null;
 
     this.methodName = methodName;
     this.methodProto = methodProto;
     this.bootstrapMethod = bootstrapMethod;
     this.bootstrapArgs = bootstrapArgs;
-    this.interfaceMethod = interfaceMethod;
+    this.interfaceMethods = interfaceMethods;
   }
 
   public static DexCallSite fromAsmInvokeDynamic(
diff --git a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
index 75f2ee8..5fe9134 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -17,6 +17,7 @@
 import com.android.tools.r8.graph.DexMethodHandle.MethodHandleType;
 import com.android.tools.r8.graph.DexValue.DexValueMethodType;
 import com.android.tools.r8.ir.code.Position;
+import com.android.tools.r8.ir.desugar.LambdaDescriptor;
 import com.android.tools.r8.kotlin.Kotlin;
 import com.android.tools.r8.naming.NamingLens;
 import com.google.common.base.Strings;
@@ -26,6 +27,7 @@
 import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.IdentityHashMap;
 import java.util.List;
@@ -228,6 +230,33 @@
   public final DexType annotationSynthesizedClassMap =
       createType("Lcom/android/tools/r8/annotations/SynthesizedClassMap;");
 
+  private static final String METAFACTORY_METHOD_NAME = "metafactory";
+  private static final String METAFACTORY_ALT_METHOD_NAME = "altMetafactory";
+
+  public final DexType metafactoryType = createType("Ljava/lang/invoke/LambdaMetafactory;");
+  public final DexType callSiteType = createType("Ljava/lang/invoke/CallSite;");
+  public final DexType lookupType = createType("Ljava/lang/invoke/MethodHandles$Lookup;");
+  public final DexType serializableType = createType("Ljava/io/Serializable;");
+
+  public final DexMethod metafactoryMethod =
+      createMethod(
+          metafactoryType,
+          createProto(
+              callSiteType,
+              lookupType,
+              stringType,
+              methodTypeType,
+              methodTypeType,
+              methodHandleType,
+              methodTypeType),
+          createString(METAFACTORY_METHOD_NAME));
+
+  public final DexMethod metafactoryAltMethod =
+      createMethod(
+          metafactoryType,
+          createProto(callSiteType, lookupType, stringType, methodTypeType, objectArrayType),
+          createString(METAFACTORY_ALT_METHOD_NAME));
+
   private boolean skipNameValidationForTesting = false;
 
   public void setSkipNameValidationForTesting(boolean skipNameValidationForTesting) {
@@ -545,23 +574,46 @@
       DexString methodName, DexProto methodProto,
       DexMethodHandle bootstrapMethod, List<DexValue> bootstrapArgs) {
     assert !sorted;
-    String bootstrapClass = bootstrapMethod.asMethod().holder.toDescriptorString();
-    DexMethod interfaceMethod = null;
-    if (bootstrapClass.equals("Ljava/lang/invoke/LambdaMetafactory;")) {
-      if (methodName.toString().equals("metafactory")) {
-        DexType interfaceType = methodProto.returnType;
-        assert bootstrapArgs.size() == 3;
-        // bootstrapArgs contains samMethodType, implMethod and instantiatedMethodType.
-        DexValueMethodType samMethodType = (DexValueMethodType) bootstrapArgs.get(0);
-        interfaceMethod = createMethod(interfaceType, samMethodType.value, methodName);
-      }
-      // TODO(mathiasr): Support altMetafactory, possibly using ir.desugar.LambdaDescriptor
-    }
+    List<DexMethod> interfaceMethods =
+        getCallSiteInterfaceMethods(methodName, methodProto, bootstrapMethod, bootstrapArgs);
     DexCallSite callSite =
-        new DexCallSite(methodName, methodProto, bootstrapMethod, bootstrapArgs, interfaceMethod);
+        new DexCallSite(methodName, methodProto, bootstrapMethod, bootstrapArgs, interfaceMethods);
     return canonicalize(callSites, callSite);
   }
 
+  private List<DexMethod> getCallSiteInterfaceMethods(
+      DexString methodName,
+      DexProto methodProto,
+      DexMethodHandle bootstrapMethodHandle,
+      List<DexValue> bootstrapArgs) {
+    // TODO(mathiasr): Unify this with LambdaDescriptor.infer().
+    if (!bootstrapMethodHandle.type.isInvokeStatic()) {
+      return Collections.emptyList();
+    }
+    DexMethod bootstrapMethod = bootstrapMethodHandle.asMethod();
+    if (bootstrapMethod != metafactoryMethod && bootstrapMethod != metafactoryAltMethod) {
+      return Collections.emptyList();
+    }
+    DexType interfaceType = methodProto.returnType;
+    assert bootstrapMethod == metafactoryAltMethod || bootstrapArgs.size() == 3;
+    // Signature of main functional interface method.
+    // In Java docs, this argument is named 'samMethodType'.
+    DexValueMethodType funcErasedSignature = (DexValueMethodType) bootstrapArgs.get(0);
+    DexMethod mainMethod = createMethod(interfaceType, funcErasedSignature.value, methodName);
+    if (bootstrapMethod == metafactoryAltMethod) {
+      List<DexMethod> result = new ArrayList<>();
+      result.add(mainMethod);
+      LambdaDescriptor.extractAltMetafactory(
+          this,
+          bootstrapArgs,
+          type -> result.add(createMethod(type, funcErasedSignature.value, methodName)),
+          bridge -> {});
+      return result;
+    } else {
+      return Collections.singletonList(mainMethod);
+    }
+  }
+
   public DexMethod createMethod(DexString clazzDescriptor, DexString name,
       DexString returnTypeDescriptor,
       DexString[] parameterDescriptors) {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/CfBuilder.java b/src/main/java/com/android/tools/r8/ir/conversion/CfBuilder.java
index 7c04392..8dd9162 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/CfBuilder.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/CfBuilder.java
@@ -7,6 +7,9 @@
 import com.android.tools.r8.cf.LoadStoreHelper;
 import com.android.tools.r8.cf.TypeVerificationHelper;
 import com.android.tools.r8.cf.code.CfFrame;
+import com.android.tools.r8.cf.code.CfFrame.Uninitialized;
+import com.android.tools.r8.cf.code.CfFrame.UninitializedNew;
+import com.android.tools.r8.cf.code.CfFrame.UninitializedThis;
 import com.android.tools.r8.cf.code.CfInstruction;
 import com.android.tools.r8.cf.code.CfLabel;
 import com.android.tools.r8.cf.code.CfPosition;
@@ -28,8 +31,10 @@
 import com.android.tools.r8.ir.code.Instruction;
 import com.android.tools.r8.ir.code.InstructionIterator;
 import com.android.tools.r8.ir.code.InstructionListIterator;
+import com.android.tools.r8.ir.code.InvokeDirect;
 import com.android.tools.r8.ir.code.JumpInstruction;
 import com.android.tools.r8.ir.code.Load;
+import com.android.tools.r8.ir.code.NewInstance;
 import com.android.tools.r8.ir.code.Position;
 import com.android.tools.r8.ir.code.StackValue;
 import com.android.tools.r8.ir.code.Store;
@@ -42,9 +47,11 @@
 import it.unimi.dsi.fastutil.ints.Int2ReferenceMap.Entry;
 import it.unimi.dsi.fastutil.ints.Int2ReferenceOpenHashMap;
 import it.unimi.dsi.fastutil.ints.Int2ReferenceSortedMap;
+import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.Deque;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
@@ -77,6 +84,10 @@
 
   private AppInfoWithSubtyping appInfo;
 
+  private Map<NewInstance, List<InvokeDirect>> initializers;
+  private List<InvokeDirect> thisInitializers;
+  private Map<NewInstance, CfLabel> newInstanceLabels;
+
   // Internal abstraction of the stack values and height.
   private static class Stack {
     int maxHeight = 0;
@@ -110,6 +121,7 @@
 
   public CfCode build(
       CodeRewriter rewriter, InternalOptions options, AppInfoWithSubtyping appInfo) {
+    computeInitializers();
     types = new TypeVerificationHelper(code, factory, appInfo).computeVerificationTypes();
     splitExceptionalBlocks();
     LoadStoreHelper loadStoreHelper = new LoadStoreHelper(code, types);
@@ -133,6 +145,39 @@
     return resolvedField == null ? field : resolvedField.field;
   }
 
+  private void computeInitializers() {
+    assert initializers == null;
+    assert thisInitializers == null;
+    initializers = new HashMap<>();
+    for (BasicBlock block : code.blocks) {
+      for (Instruction insn : block.getInstructions()) {
+        if (insn.isNewInstance()) {
+          initializers.put(insn.asNewInstance(), computeInitializers(insn.outValue()));
+        } else if (insn.isArgument() && method.isInstanceInitializer()) {
+          if (insn.outValue().isThis()) {
+            // By JVM8 §4.10.1.9 (invokespecial), a this() or super() call in a constructor
+            // changes the type of `this` from uninitializedThis
+            // to the type of the class of the <init> method.
+            thisInitializers = computeInitializers(insn.outValue());
+          }
+        }
+      }
+    }
+    assert !(method.isInstanceInitializer() && thisInitializers == null);
+  }
+
+  private List<InvokeDirect> computeInitializers(Value value) {
+    List<InvokeDirect> initializers = new ArrayList<>();
+    for (Instruction user : value.uniqueUsers()) {
+      if (user instanceof InvokeDirect
+          && user.inValues().get(0) == value
+          && user.asInvokeDirect().getInvokedMethod().name == factory.constructorMethodName) {
+        initializers.add(user.asInvokeDirect());
+      }
+    }
+    return initializers;
+  }
+
   // Split all blocks with throwing instructions and exceptional edges such that any non-throwing
   // instructions that might define values prior to the throwing exception are excluded from the
   // try-catch range. Failure to do so will result in code that does not verify on the JVM.
@@ -203,6 +248,7 @@
     List<CfTryCatch> tryCatchRanges = new ArrayList<>();
     labels = new HashMap<>(code.blocks.size());
     emittedLabels = new HashSet<>(code.blocks.size());
+    newInstanceLabels = new HashMap<>(initializers.size());
     instructions = new ArrayList<>();
     ListIterator<BasicBlock> blockIterator = code.listIterator();
     BasicBlock block = blockIterator.next();
@@ -211,6 +257,7 @@
     BasicBlock pendingFrame = null;
     boolean previousFallthrough = false;
     do {
+      assert stack.isEmpty();
       CatchHandlers<BasicBlock> handlers = block.getCatchHandlers();
       if (!tryCatchHandlers.equals(handlers)) {
         if (!tryCatchHandlers.isEmpty()) {
@@ -230,7 +277,6 @@
       // If previousBlock is fallthrough, then it is counted in getPredecessors().size(), but
       // we only want to set a pendingFrame if we have a predecessor which is not previousBlock.
       if (block.getPredecessors().size() > (previousFallthrough ? 1 : 0)) {
-        assert stack.isEmpty();
         pendingFrame = block;
         emitLabel(getLabel(block));
       }
@@ -318,6 +364,9 @@
           pendingLocalChanges = true;
         }
       } else {
+        if (instruction.isNewInstance()) {
+          newInstanceLabels.put(instruction.asNewInstance(), ensureLabel());
+        }
         updatePositionAndLocals(instruction);
         instruction.buildCf(this);
       }
@@ -400,9 +449,11 @@
 
     Collection<Value> locals = registerAllocator.getLocalsAtBlockEntry(block);
     Int2ReferenceSortedMap<DexType> mapping = new Int2ReferenceAVLTreeMap<>();
+    Int2ReferenceSortedMap<Uninitialized> allocators = new Int2ReferenceAVLTreeMap<>();
 
     for (Value local : locals) {
       DexType type;
+      Uninitialized allocator = null;
       switch (local.outType()) {
         case INT:
           type = factory.intType;
@@ -418,14 +469,64 @@
           break;
         case OBJECT:
           type = types.get(local);
+          allocator = findAllocator(block, local);
           break;
         default:
           throw new Unreachable(
               "Unexpected local type: " + local.outType() + " for local: " + local);
       }
       mapping.put(getLocalRegister(local), type);
+      if (allocator != null) {
+        allocators.put(getLocalRegister(local), allocator);
+      }
     }
-    instructions.add(new CfFrame(mapping, stackTypes));
+    instructions.add(new CfFrame(mapping, allocators, stackTypes));
+  }
+
+  private Uninitialized findAllocator(BasicBlock liveBlock, Value value) {
+    Instruction definition = value.definition;
+    while (definition != null && (definition.isStore() || definition.isLoad())) {
+      definition = definition.inValues().get(0).definition;
+    }
+    if (definition == null) {
+      return null;
+    }
+    Uninitialized res;
+    if (definition.isNewInstance()) {
+      res = new UninitializedNew(newInstanceLabels.get(definition.asNewInstance()));
+    } else if (definition.isArgument()
+        && method.isInstanceInitializer()
+        && definition.outValue().isThis()) {
+      res = new UninitializedThis();
+    } else {
+      return null;
+    }
+    BasicBlock definitionBlock = definition.getBlock();
+    Set<BasicBlock> visited = new HashSet<>();
+    Deque<BasicBlock> toVisit = new ArrayDeque<>();
+    List<InvokeDirect> valueInitializers =
+        definition.isArgument() ? thisInitializers : initializers.get(definition.asNewInstance());
+    for (InvokeDirect initializer : valueInitializers) {
+      BasicBlock initializerBlock = initializer.getBlock();
+      if (initializerBlock == liveBlock) {
+        return res;
+      }
+      if (initializerBlock != definitionBlock && visited.add(initializerBlock)) {
+        toVisit.addLast(initializerBlock);
+      }
+    }
+    while (!toVisit.isEmpty()) {
+      BasicBlock block = toVisit.removeLast();
+      for (BasicBlock predecessor : block.getPredecessors()) {
+        if (predecessor == liveBlock) {
+          return res;
+        }
+        if (predecessor != definitionBlock && visited.add(predecessor)) {
+          toVisit.addLast(predecessor);
+        }
+      }
+    }
+    return null;
   }
 
   private void emitLabel(CfLabel label) {
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaDescriptor.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaDescriptor.java
index 5d52523..49a797a 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaDescriptor.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaDescriptor.java
@@ -21,9 +21,10 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
+import java.util.function.Consumer;
 
 // Represents the lambda descriptor inferred from calls site.
-final class LambdaDescriptor {
+public final class LambdaDescriptor {
   private static final int LAMBDA_ALT_SERIALIZABLE = 1;
   private static final int LAMBDA_ALT_HAS_EXTRA_INTERFACES = 2;
   private static final int LAMBDA_ALT_HAS_BRIDGES = 4;
@@ -227,8 +228,8 @@
     }
 
     DexMethod bootstrapMethod = callSite.bootstrapMethod.asMethod();
-    boolean isMetafactoryMethod = bootstrapMethod == rewriter.metafactoryMethod;
-    boolean isAltMetafactoryMethod = bootstrapMethod == rewriter.metafactoryAltMethod;
+    boolean isMetafactoryMethod = bootstrapMethod == rewriter.factory.metafactoryMethod;
+    boolean isAltMetafactoryMethod = bootstrapMethod == rewriter.factory.metafactoryAltMethod;
     if (!isMetafactoryMethod && !isAltMetafactoryMethod) {
       // It is not a lambda, thus no need to manage this call site.
       return LambdaDescriptor.MATCH_FAILED;
@@ -240,18 +241,18 @@
 
     // Signature of main functional interface method.
     DexValue.DexValueMethodType funcErasedSignature =
-        getBootstrapArgument(callSite, 0, DexValue.DexValueMethodType.class);
+        getBootstrapArgument(callSite.bootstrapArgs, 0, DexValue.DexValueMethodType.class);
 
     // Method handle of the implementation method.
     DexMethodHandle lambdaImplMethodHandle =
-        getBootstrapArgument(callSite, 1, DexValue.DexValueMethodHandle.class).value;
+        getBootstrapArgument(callSite.bootstrapArgs, 1, DexValue.DexValueMethodHandle.class).value;
     // Even though there are some limitations on which method handle kinds are
     // allowed for lambda impl-methods, there is no way to detect unsupported
     // handle kinds after they are transformed into DEX method handle.
 
     // Signature to be enforced on main method.
     DexValue.DexValueMethodType funcEnforcedSignature =
-        getBootstrapArgument(callSite, 2, DexValue.DexValueMethodType.class);
+        getBootstrapArgument(callSite.bootstrapArgs, 2, DexValue.DexValueMethodType.class);
     if (!isEnforcedSignatureValid(
         rewriter, funcEnforcedSignature.value, funcErasedSignature.value)) {
       throw new Unreachable(
@@ -277,67 +278,70 @@
             "Unexpected number of metafactory method arguments in " + callSite.toString());
       }
     } else {
-      extractExtraLambdaInfo(rewriter, callSite, match);
+      extractAltMetafactory(
+          rewriter.factory,
+          callSite.bootstrapArgs,
+          interfaceType -> {
+            if (!match.interfaces.contains(interfaceType)) {
+              match.interfaces.add(interfaceType);
+            }
+          },
+          match.bridges::add);
     }
 
     return match;
   }
 
-  private static void extractExtraLambdaInfo(
-      LambdaRewriter rewriter, DexCallSite callSite, LambdaDescriptor match) {
+  public static void extractAltMetafactory(
+      DexItemFactory dexItemFactory,
+      List<DexValue> bootstrapArgs,
+      Consumer<DexType> interfaceConsumer,
+      Consumer<DexProto> bridgeConsumer) {
     int argIndex = 3;
-    int flagsArg = getBootstrapArgument(
-        callSite, argIndex++, DexValue.DexValueInt.class).value;
+    int flagsArg =
+        getBootstrapArgument(bootstrapArgs, argIndex++, DexValue.DexValueInt.class).value;
     assert (flagsArg & ~LAMBDA_ALT_MASK) == 0;
 
     // Load extra interfaces if any.
     if ((flagsArg & LAMBDA_ALT_HAS_EXTRA_INTERFACES) != 0) {
-      int count = getBootstrapArgument(
-          callSite, argIndex++, DexValue.DexValueInt.class).value;
+      int count = getBootstrapArgument(bootstrapArgs, argIndex++, DexValue.DexValueInt.class).value;
       for (int i = 0; i < count; i++) {
-        DexType type = getBootstrapArgument(
-            callSite, argIndex++, DexValue.DexValueType.class).value;
-        if (!match.interfaces.contains(type)) {
-          match.interfaces.add(type);
-        }
+        DexType interfaceType =
+            getBootstrapArgument(bootstrapArgs, argIndex++, DexValue.DexValueType.class).value;
+        interfaceConsumer.accept(interfaceType);
       }
     }
 
     // If the lambda is serializable, add it.
     if ((flagsArg & LAMBDA_ALT_SERIALIZABLE) != 0) {
-      if (!match.interfaces.contains(rewriter.serializableType)) {
-        match.interfaces.add(rewriter.serializableType);
-      }
+      interfaceConsumer.accept(dexItemFactory.serializableType);
     }
 
     // Load bridges if any.
     if ((flagsArg & LAMBDA_ALT_HAS_BRIDGES) != 0) {
-      int count = getBootstrapArgument(
-          callSite, argIndex++, DexValue.DexValueInt.class).value;
+      int count = getBootstrapArgument(bootstrapArgs, argIndex++, DexValue.DexValueInt.class).value;
       for (int i = 0; i < count; i++) {
-        DexProto bridgeProto = getBootstrapArgument(
-            callSite, argIndex++, DexValue.DexValueMethodType.class).value;
-        match.bridges.add(bridgeProto);
+        DexProto bridgeProto =
+            getBootstrapArgument(bootstrapArgs, argIndex++, DexValue.DexValueMethodType.class)
+                .value;
+        bridgeConsumer.accept(bridgeProto);
       }
     }
 
-    if (callSite.bootstrapArgs.size() != argIndex) {
-      throw new Unreachable(
-          "Unexpected number of metafactory method arguments in " + callSite.toString());
+    if (bootstrapArgs.size() != argIndex) {
+      throw new Unreachable("Unexpected number of metafactory method arguments in DexCallSite");
     }
   }
 
   @SuppressWarnings("unchecked")
-  private static <T> T getBootstrapArgument(DexCallSite callSite, int i, Class<T> clazz) {
-    List<DexValue> bootstrapArgs = callSite.bootstrapArgs;
+  private static <T> T getBootstrapArgument(List<DexValue> bootstrapArgs, int i, Class<T> clazz) {
     if (bootstrapArgs.size() < i) {
-      throw new Unreachable("Expected to find at least "
-          + i + " bootstrap arguments in " + callSite.toString());
+      throw new Unreachable(
+          "Expected to find at least " + i + " bootstrap arguments in DexCallSite");
     }
     DexValue value = bootstrapArgs.get(i);
     if (!clazz.isAssignableFrom(value.getClass())) {
-      throw new Unreachable("Unexpected type of "
-          + "bootstrap arguments #" + i + " in " + callSite.toString());
+      throw new Unreachable("Unexpected type of bootstrap arguments #" + i + " in DexCallSite");
     }
     return (T) value;
   }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java
index aad7961..82792df 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java
@@ -41,16 +41,8 @@
  * lambda class generation, and instruction patching.
  */
 public class LambdaRewriter {
-  private static final String METAFACTORY_TYPE_DESCR = "Ljava/lang/invoke/LambdaMetafactory;";
-  private static final String CALLSITE_TYPE_DESCR = "Ljava/lang/invoke/CallSite;";
-  private static final String LOOKUP_TYPE_DESCR = "Ljava/lang/invoke/MethodHandles$Lookup;";
-  private static final String METHODTYPE_TYPE_DESCR = "Ljava/lang/invoke/MethodType;";
-  private static final String METHODHANDLE_TYPE_DESCR = "Ljava/lang/invoke/MethodHandle;";
-  private static final String SERIALIZABLE_TYPE_DESCR = "Ljava/io/Serializable;";
   private static final String SERIALIZED_LAMBDA_TYPE_DESCR = "Ljava/lang/invoke/SerializedLambda;";
 
-  private static final String METAFACTORY_METHOD_NAME = "metafactory";
-  private static final String METAFACTORY_ALT_METHOD_NAME = "altMetafactory";
   private static final String DESERIALIZE_LAMBDA_METHOD_NAME = "$deserializeLambda$";
 
   // Public for testing.
@@ -62,12 +54,8 @@
   final AppInfo appInfo;
   final DexItemFactory factory;
 
-  final DexMethod metafactoryMethod;
   final DexMethod objectInitMethod;
 
-  final DexMethod metafactoryAltMethod;
-  final DexType serializableType;
-
   final DexString constructorName;
   final DexString classConstructorName;
   final DexString instanceFieldName;
@@ -97,28 +85,11 @@
     this.factory = converter.appInfo.dexItemFactory;
     this.appInfo = converter.appInfo;
 
-    DexType metafactoryType = factory.createType(METAFACTORY_TYPE_DESCR);
-    DexType callSiteType = factory.createType(CALLSITE_TYPE_DESCR);
-    DexType lookupType = factory.createType(LOOKUP_TYPE_DESCR);
-    DexType methodTypeType = factory.createType(METHODTYPE_TYPE_DESCR);
-    DexType methodHandleType = factory.createType(METHODHANDLE_TYPE_DESCR);
-
-    this.metafactoryMethod = factory.createMethod(metafactoryType,
-        factory.createProto(callSiteType, lookupType, factory.stringType, methodTypeType,
-            methodTypeType, methodHandleType, methodTypeType),
-        factory.createString(METAFACTORY_METHOD_NAME));
-
-    this.metafactoryAltMethod = factory.createMethod(metafactoryType,
-        factory.createProto(callSiteType, lookupType, factory.stringType, methodTypeType,
-            factory.objectArrayType),
-        factory.createString(METAFACTORY_ALT_METHOD_NAME));
-
     this.constructorName = factory.createString(Constants.INSTANCE_INITIALIZER_NAME);
     DexProto initProto = factory.createProto(factory.voidType);
     this.objectInitMethod = factory.createMethod(factory.objectType, initProto, constructorName);
     this.classConstructorName = factory.createString(Constants.CLASS_INITIALIZER_NAME);
     this.instanceFieldName = factory.createString(LAMBDA_INSTANCE_FIELD_NAME);
-    this.serializableType = factory.createType(SERIALIZABLE_TYPE_DESCR);
 
     this.deserializeLambdaMethodName = factory.createString(DESERIALIZE_LAMBDA_METHOD_NAME);
     this.deserializeLambdaMethodProto = factory.createProto(
diff --git a/src/main/java/com/android/tools/r8/naming/MethodNameMinifier.java b/src/main/java/com/android/tools/r8/naming/MethodNameMinifier.java
index ce37763..25a84b6 100644
--- a/src/main/java/com/android/tools/r8/naming/MethodNameMinifier.java
+++ b/src/main/java/com/android/tools/r8/naming/MethodNameMinifier.java
@@ -12,7 +12,6 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.shaking.RootSetBuilder.RootSet;
 import com.android.tools.r8.utils.InternalOptions;
-import com.android.tools.r8.utils.MethodJavaSignatureEquivalence;
 import com.android.tools.r8.utils.MethodSignatureEquivalence;
 import com.android.tools.r8.utils.Timing;
 import com.google.common.base.Equivalence;
@@ -88,13 +87,10 @@
  */
 class MethodNameMinifier extends MemberNameMinifier<DexMethod, DexProto> {
 
-  private final Equivalence<DexMethod> equivalence;
+  private final Equivalence<DexMethod> equivalence = MethodSignatureEquivalence.get();
 
   MethodNameMinifier(AppInfoWithSubtyping appInfo, RootSet rootSet, InternalOptions options) {
     super(appInfo, rootSet, options);
-    equivalence = overloadAggressively
-        ? MethodSignatureEquivalence.get()
-        : MethodJavaSignatureEquivalence.get();
   }
 
   @Override
diff --git a/src/test/java/com/android/tools/r8/cf/UninitializedInFrameDump.java b/src/test/java/com/android/tools/r8/cf/UninitializedInFrameDump.java
new file mode 100644
index 0000000..bac896e
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/cf/UninitializedInFrameDump.java
@@ -0,0 +1,179 @@
+// Copyright (c) 2018, 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.cf;
+
+import java.util.*;
+import org.objectweb.asm.*;
+
+public class UninitializedInFrameDump implements Opcodes {
+
+  public static byte[] dump() throws Exception {
+
+    ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
+    FieldVisitor fv;
+    MethodVisitor mv;
+    AnnotationVisitor av0;
+
+    cw.visit(
+        V1_8,
+        ACC_PUBLIC + ACC_SUPER,
+        "com/android/tools/r8/cf/UninitializedInFrameTest",
+        null,
+        "java/lang/Object",
+        null);
+
+    // The constructor UninitializedInFrameTest(int i) has been modified
+    // to add a jump back to the entry block.
+    {
+      mv = cw.visitMethod(ACC_PUBLIC, "<init>", "(I)V", null, null);
+      mv.visitCode();
+      Label l = new Label(); // Added
+      mv.visitLabel(l); // Added
+      mv.visitVarInsn(ALOAD, 0);
+      mv.visitVarInsn(ILOAD, 1);
+      mv.visitInsn(ICONST_1);
+      mv.visitInsn(ISUB);
+      mv.visitInsn(DUP); // Added
+      mv.visitIntInsn(BIPUSH, 42);
+      Label l0 = new Label();
+      mv.visitJumpInsn(IF_ICMPLT, l0);
+      // mv.visitInsn(ICONST_1);
+      mv.visitVarInsn(ISTORE, 1); // Added
+      mv.visitInsn(POP); // Added
+      mv.visitJumpInsn(GOTO, l); // Added
+      Label l1 = new Label();
+      mv.visitJumpInsn(GOTO, l1);
+      mv.visitLabel(l0);
+      mv.visitInsn(POP); // Added
+      mv.visitInsn(ICONST_0);
+      mv.visitLabel(l1);
+      mv.visitMethodInsn(
+          INVOKESPECIAL,
+          "com/android/tools/r8/cf/UninitializedInFrameTest",
+          "<init>",
+          "(Z)V",
+          false);
+      mv.visitInsn(RETURN);
+      mv.visitMaxs(-1, -1);
+      // mv.visitMaxs(3, 2);
+      mv.visitEnd();
+    }
+    {
+      mv = cw.visitMethod(ACC_PRIVATE, "<init>", "(Z)V", null, null);
+      mv.visitCode();
+      mv.visitVarInsn(ALOAD, 0);
+      mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+      mv.visitInsn(RETURN);
+      mv.visitMaxs(-1, -1);
+      // mv.visitMaxs(1, 2);
+      mv.visitEnd();
+    }
+    {
+      mv = cw.visitMethod(ACC_PUBLIC + ACC_STATIC, "main", "([Ljava/lang/String;)V", null, null);
+      mv.visitCode();
+      mv.visitVarInsn(ALOAD, 0);
+      mv.visitInsn(ARRAYLENGTH);
+      Label l0 = new Label();
+      mv.visitJumpInsn(IFEQ, l0);
+      mv.visitTypeInsn(NEW, "java/lang/RuntimeException");
+      mv.visitInsn(DUP);
+      mv.visitVarInsn(ALOAD, 0);
+      mv.visitInsn(ARRAYLENGTH);
+      mv.visitIntInsn(BIPUSH, 42);
+      Label l1 = new Label();
+      mv.visitJumpInsn(IF_ICMPNE, l1);
+      // mv.visitTypeInsn(NEW, "java/lang/RuntimeException");
+      // mv.visitInsn(DUP);
+      mv.visitTypeInsn(NEW, "java/lang/IllegalArgumentException");
+      mv.visitInsn(DUP);
+      mv.visitMethodInsn(
+          INVOKESPECIAL, "java/lang/IllegalArgumentException", "<init>", "()V", false);
+      mv.visitMethodInsn(
+          INVOKESPECIAL, "java/lang/RuntimeException", "<init>", "(Ljava/lang/Throwable;)V", false);
+      mv.visitVarInsn(ASTORE, 1);
+      // At this point, stack is empty.
+      Label l2 = new Label();
+      mv.visitJumpInsn(GOTO, l2);
+      mv.visitLabel(l1);
+      // At this point, stack contains two copies of uninitialized RuntimeException.
+      // mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
+      // mv.visitTypeInsn(NEW, "java/lang/RuntimeException");
+      // mv.visitInsn(DUP);
+      mv.visitTypeInsn(NEW, "java/lang/StringBuilder");
+      mv.visitInsn(DUP);
+      mv.visitMethodInsn(INVOKESPECIAL, "java/lang/StringBuilder", "<init>", "()V", false);
+      mv.visitLdcInsn("You supplied ");
+      mv.visitMethodInsn(
+          INVOKEVIRTUAL,
+          "java/lang/StringBuilder",
+          "append",
+          "(Ljava/lang/String;)Ljava/lang/StringBuilder;",
+          false);
+      mv.visitVarInsn(ALOAD, 0);
+      mv.visitInsn(ARRAYLENGTH);
+      mv.visitMethodInsn(
+          INVOKEVIRTUAL,
+          "java/lang/StringBuilder",
+          "append",
+          "(I)Ljava/lang/StringBuilder;",
+          false);
+      mv.visitVarInsn(ALOAD, 0);
+      mv.visitInsn(ARRAYLENGTH);
+      mv.visitInsn(ICONST_1);
+      Label l3 = new Label();
+      mv.visitJumpInsn(IF_ICMPNE, l3);
+      mv.visitLdcInsn(" arg");
+      Label l4 = new Label();
+      mv.visitJumpInsn(GOTO, l4);
+      mv.visitLabel(l3);
+      // At this point, stack contains two copies of uninitialized RuntimeException.
+      // Note that asmifier seems to produce incorrect labels for the uninitialized type.
+      // mv.visitFrame(Opcodes.F_FULL, 1, new Object[] {"[Ljava/lang/String;"}, 3, new Object[] {l1,
+      // l1, "java/lang/StringBuilder"});
+      mv.visitLdcInsn(" args");
+      mv.visitLabel(l4);
+      // At this point, stack contains two copies of uninitialized RuntimeException.
+      // mv.visitFrame(Opcodes.F_FULL, 1, new Object[] {"[Ljava/lang/String;"}, 4, new Object[] {l1,
+      // l1, "java/lang/StringBuilder", "java/lang/String"});
+      mv.visitMethodInsn(
+          INVOKEVIRTUAL,
+          "java/lang/StringBuilder",
+          "append",
+          "(Ljava/lang/String;)Ljava/lang/StringBuilder;",
+          false);
+      mv.visitMethodInsn(
+          INVOKEVIRTUAL, "java/lang/StringBuilder", "toString", "()Ljava/lang/String;", false);
+      mv.visitMethodInsn(
+          INVOKESPECIAL, "java/lang/RuntimeException", "<init>", "(Ljava/lang/String;)V", false);
+      mv.visitVarInsn(ASTORE, 1);
+      mv.visitLabel(l2);
+      // At this point, stack is empty, and local 1 contains an initialized RuntimeException.
+      // mv.visitFrame(Opcodes.F_APPEND,1, new Object[] {"java/lang/RuntimeException"}, 0, null);
+      mv.visitVarInsn(ALOAD, 0);
+      mv.visitInsn(ARRAYLENGTH);
+      mv.visitInsn(ICONST_2);
+      mv.visitInsn(IREM);
+      Label l5 = new Label();
+      mv.visitJumpInsn(IFNE, l5);
+      mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
+      mv.visitVarInsn(ALOAD, 1);
+      mv.visitMethodInsn(
+          INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/Object;)V", false);
+      mv.visitLabel(l5);
+      // mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
+      mv.visitVarInsn(ALOAD, 1);
+      mv.visitInsn(ATHROW);
+      mv.visitLabel(l0);
+      // mv.visitFrame(Opcodes.F_CHOP,1, null, 0, null);
+      mv.visitInsn(RETURN);
+      mv.visitMaxs(-1, -1);
+      // mv.visitMaxs(5, 2);
+      mv.visitEnd();
+    }
+    cw.visitEnd();
+
+    return cw.toByteArray();
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/cf/UninitializedInFrameTest.java b/src/test/java/com/android/tools/r8/cf/UninitializedInFrameTest.java
new file mode 100644
index 0000000..4479796
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/cf/UninitializedInFrameTest.java
@@ -0,0 +1,54 @@
+// Copyright (c) 2018, 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.cf;
+
+public class UninitializedInFrameTest {
+  int v;
+
+  public UninitializedInFrameTest(int i) {
+    // In UninitializedInFrameDump, this method is changed to:
+    //     while (i-1 >= 42) {i = i-1;} this(i-1 >= 42);
+    // ...which is invalid in Java source since this() must be the first statement.
+    // Put "i-1 >= 42" in the code here to aid the manual editing in UninitializedInFrameDump.
+    this(i - 1 >= 42);
+  }
+
+  public UninitializedInFrameTest(boolean b) {
+    v = b ? 42 : 0;
+    System.out.println(this);
+    // Add an InvokeDirect that has 'this' as argument to ensure we don't consider it to be
+    // an initialization for 'this'.
+    if (!b) {
+      throw new AssertionError(this);
+    }
+  }
+
+  @Override
+  public String toString() {
+    return "Hello world! " + v;
+  }
+
+  public static void main(String[] args) {
+    try {
+      new UninitializedInFrameTest(true);
+      new UninitializedInFrameTest(45);
+    } catch (AssertionError e) {
+    }
+    if (args.length != 0) {
+      RuntimeException e;
+      if (args.length == 42) {
+        e = new RuntimeException(new IllegalArgumentException());
+      } else {
+        e =
+            new RuntimeException(
+                "You supplied " + args.length + (args.length == 1 ? " arg" : " args"));
+      }
+      if (args.length % 2 == 0) {
+        System.out.println(e);
+      }
+      throw e;
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/cf/UninitializedInFrameTestRunner.java b/src/test/java/com/android/tools/r8/cf/UninitializedInFrameTestRunner.java
new file mode 100644
index 0000000..f433a9d
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/cf/UninitializedInFrameTestRunner.java
@@ -0,0 +1,64 @@
+// Copyright (c) 2018, 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.cf;
+
+import com.android.tools.r8.ClassFileConsumer.ArchiveConsumer;
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.CompilationMode;
+import com.android.tools.r8.R8;
+import com.android.tools.r8.R8Command;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.utils.DescriptorUtils;
+import java.io.IOException;
+import java.nio.file.Path;
+import org.junit.Assert;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+public class UninitializedInFrameTestRunner {
+  static final Class CLASS = UninitializedInFrameTest.class;
+
+  @Rule
+  public TemporaryFolder temp = ToolHelper.getTemporaryFolderForTest();
+
+  @Test
+  public void test() throws Exception {
+    test(ToolHelper.getClassAsBytes(CLASS));
+  }
+
+  @Test
+  public void testDump() throws Exception {
+    test(UninitializedInFrameDump.dump());
+  }
+
+  private void test(byte[] clazz) throws CompilationFailedException, IOException {
+    Path input = temp.getRoot().toPath().resolve("input.jar");
+    Path output = temp.getRoot().toPath().resolve("output.jar");
+
+    ArchiveConsumer inputConsumer = new ArchiveConsumer(input);
+    inputConsumer.accept(clazz, DescriptorUtils.javaTypeToDescriptor(CLASS.getName()), null);
+    inputConsumer.finished(null);
+    ProcessResult runInput = ToolHelper.runJava(input, CLASS.getCanonicalName());
+    if (runInput.exitCode != 0) {
+      System.out.println(runInput);
+    }
+    Assert.assertEquals(0, runInput.exitCode);
+
+    R8.run(
+        R8Command.builder()
+            .setMode(CompilationMode.DEBUG)
+            .addClassProgramData(clazz, Origin.unknown())
+            .addLibraryFiles(ToolHelper.getAndroidJar(ToolHelper.getMinApiLevelForDexVm()))
+            .setProgramConsumer(new ArchiveConsumer(output))
+            .build());
+    ProcessResult runOutput = ToolHelper.runJava(output, CLASS.getCanonicalName());
+    if (runOutput.exitCode != 0) {
+      System.out.println(runOutput);
+    }
+    Assert.assertEquals(runInput.toString(), runOutput.toString());
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterTests.java b/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterTests.java
index 19a5ee2..cf87d46 100644
--- a/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterTests.java
+++ b/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterTests.java
@@ -89,9 +89,9 @@
 
     if (useOptions) {
       Options options = new Options();
-      options.inputArchives.add(inputZip.toString());
-      options.featureSplitMapping = splitSpec.toString();
-      options.splitBaseName = output.toString();
+      options.addInputArchive(inputZip.toString());
+      options.setFeatureSplitMapping(splitSpec.toString());
+      options.setSplitBaseName(output.toString());
       DexSplitter.run(options);
     } else {
       DexSplitter.main(
@@ -235,12 +235,12 @@
     featureStream.close();
     if (useOptions) {
       Options options = new Options();
-      options.inputArchives.add(inputZip.toString());
-      options.splitBaseName = output.toString();
+      options.addInputArchive(inputZip.toString());
+      options.setSplitBaseName(output.toString());
       if (explicitBase) {
-        options.featureJars.add(baseJar.toString());
+        options.addFeatureJar(baseJar.toString());
       }
-      options.featureJars.add(featureJar.toString());
+      options.addFeatureJar(featureJar.toString());
       DexSplitter.run(options);
     } else {
       List<String> args = Lists.newArrayList(
diff --git a/src/test/java/com/android/tools/r8/ir/regalloc/B77240639.java b/src/test/java/com/android/tools/r8/ir/regalloc/B77240639.java
new file mode 100644
index 0000000..440f4f3
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/regalloc/B77240639.java
@@ -0,0 +1,820 @@
+// Copyright (c) 2018, 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.regalloc;
+
+import static com.android.tools.r8.utils.DexInspectorMatchers.isPresent;
+import static org.junit.Assert.assertThat;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.DexInspector;
+import com.android.tools.r8.utils.DexInspector.ClassSubject;
+import java.util.List;
+import java.util.Map;
+import org.junit.Ignore;
+import org.junit.Test;
+
+public class B77240639 extends TestBase {
+  @Ignore("b/77240639")
+  @Test
+  public void test() throws Exception {
+    AndroidApp app = compileWithD8(readClasses(TestClass.class));
+    DexInspector inspector = new DexInspector(app);
+    ClassSubject clazz = inspector.clazz(TestClass.class);
+    assertThat(clazz, isPresent());
+  }
+}
+
+class TestClass {
+  private boolean b;
+  private boolean b_flag = false;
+  private Boolean ob;
+  private boolean ob_flag = false;
+  private List<Boolean> vb;
+  private boolean vb_flag = false;
+  private List<Boolean> vob;
+  private boolean vob_flag = false;
+  private Map<String, Boolean> db;
+  private boolean db_flag = false;
+  private Map<String, Boolean> dob;
+  private boolean dob_flag = false;
+  private int i;
+  private boolean i_flag = false;
+  private Integer oi;
+  private boolean oi_flag = false;
+  private List<Boolean> vi;
+  private boolean vi_flag = false;
+  private List<Boolean> voi;
+  private boolean voi_flag = false;
+  private Map<String, Boolean> di;
+  private boolean di_flag = false;
+  private Map<String, Boolean> doi;
+  private boolean doi_flag = false;
+  private int ui;
+  private boolean ui_flag = false;
+  private Integer oui;
+  private boolean oui_flag = false;
+  private List<Boolean> vui;
+  private boolean vui_flag = false;
+  private List<Boolean> voui;
+  private boolean voui_flag = false;
+  private Map<String, Boolean> dui;
+  private boolean dui_flag = false;
+  private Map<String, Boolean> doui;
+  private boolean doui_flag = false;
+  private long i64;
+  private boolean i64_flag = false;
+  private Long oi64;
+  private boolean oi64_flag = false;
+  private List<Boolean> vi64;
+  private boolean vi64_flag = false;
+  private List<Boolean> voi64;
+  private boolean voi64_flag = false;
+  private Map<String, Boolean> di64;
+  private boolean di64_flag = false;
+  private Map<String, Boolean> doi64;
+  private boolean doi64_flag = false;
+  private float fl;
+  private boolean fl_flag = false;
+  private Float ofl;
+  private boolean ofl_flag = false;
+  private List<Boolean> vfl;
+  private boolean vfl_flag = false;
+  private List<Boolean> vofl;
+  private boolean vofl_flag = false;
+  private Map<String, Boolean> dfl;
+  private boolean dfl_flag = false;
+  private Map<String, Boolean> dofl;
+  private boolean dofl_flag = false;
+  private double d;
+  private boolean d_flag = false;
+  private Double od;
+  private boolean od_flag = false;
+  private List<Boolean> vd;
+  private boolean vd_flag = false;
+  private List<Boolean> vod;
+  private boolean vod_flag = false;
+  private Map<String, Boolean> dd;
+  private boolean dd_flag = false;
+  private Map<String, Boolean> dod;
+  private boolean dod_flag = false;
+  private String s;
+  private boolean s_flag = false;
+  private String os;
+  private boolean os_flag = false;
+  private List<Boolean> vs;
+  private boolean vs_flag = false;
+  private List<Boolean> vos;
+  private boolean vos_flag = false;
+  private Map<String, Boolean> ds;
+  private boolean ds_flag = false;
+  private Map<String, Boolean> dos;
+  private boolean dos_flag = false;
+  private long ti;
+  private boolean ti_flag = false;
+  private Long oti;
+  private boolean oti_flag = false;
+  private List<Boolean> vti;
+  private boolean vti_flag = false;
+  private List<Boolean> voti;
+  private boolean voti_flag = false;
+  private Map<String, Boolean> dti;
+  private boolean dti_flag = false;
+  private Map<String, Boolean> doti;
+  private boolean doti_flag = false;
+  private long at;
+  private boolean at_flag = false;
+  private Long oat;
+  private boolean oat_flag = false;
+  private List<Boolean> vat;
+  private boolean vat_flag = false;
+  private List<Boolean> voat;
+  private boolean voat_flag = false;
+  private Map<String, Boolean> dat;
+  private boolean dat_flag = false;
+  private Map<String, Boolean> doat;
+  private boolean doat_flag = false;
+  private long rt;
+  private boolean rt_flag = false;
+  private Long ort;
+  private boolean ort_flag = false;
+  private List<Boolean> vrt;
+  private boolean vrt_flag = false;
+  private List<Boolean> vort;
+  private boolean vort_flag = false;
+  private Map<String, Boolean> drt;
+  private boolean drt_flag = false;
+  private Map<String, Boolean> dort;
+  private boolean dort_flag = false;
+  private byte[] by;
+  private boolean by_flag = false;
+  private byte[] oby;
+  private boolean oby_flag = false;
+  private int c;
+  private boolean c_flag = false;
+  private Integer oc;
+  private boolean oc_flag = false;
+  private List<Integer> vc;
+  private boolean vc_flag = false;
+  private List<Integer> voc;
+  private boolean voc_flag = false;
+  private Map<String, Integer> dc;
+  private boolean dc_flag = false;
+  private Map<String, Integer> doc;
+  private boolean doc_flag = false;
+  private Object p;
+  private boolean p_flag = false;
+  private Object op;
+  private boolean op_flag = false;
+  private List<Object> vp;
+  private boolean vp_flag = false;
+  private List<Object> vop;
+  private boolean vop_flag = false;
+  private Map<String, Object> dp;
+  private boolean dp_flag = false;
+  private Map<String, Object> dop;
+  private boolean dop_flag = false;
+  private Object e;
+  private boolean e_flag = false;
+  private Object oe;
+  private boolean oe_flag = false;
+  private List<Object> ve;
+  private boolean ve_flag = false;
+  private List<Object> voe;
+  private boolean voe_flag = false;
+  private Map<String, Object> de;
+  private boolean de_flag = false;
+  private Map<String, Object> doe;
+  private boolean doe_flag = false;
+  private int be;
+  private boolean be_flag = false;
+  private Integer obe;
+  private boolean obe_flag = false;
+  private List<Object> vbe;
+  private boolean vbe_flag = false;
+  private List<Object> vobe;
+  private boolean vobe_flag = false;
+  private Map<String, Object> dbe;
+  private boolean dbe_flag = false;
+  private Map<String, Object> dobe;
+  private boolean dobe_flag = false;
+  private Object ts;
+  private boolean ts_flag = false;
+  private Object ots;
+  private boolean ots_flag = false;
+  private List<Object> vts;
+  private boolean vts_flag = false;
+  private List<Object> vots;
+  private boolean vots_flag = false;
+  private Map<String, Object> dts;
+  private boolean dts_flag = false;
+  private Map<String, Object> dots;
+  private boolean dots_flag = false;
+  private Object lts;
+  private boolean lts_flag = false;
+  private Object olts;
+  private boolean olts_flag = false;
+  private List<Object> vlts;
+  private boolean vlts_flag = false;
+  private List<Object> volts;
+  private boolean volts_flag = false;
+  private Map<String, Object> dlts;
+  private boolean dlts_flag = false;
+  private Map<String, Object> dolts;
+  private boolean dolts_flag = false;
+  private Object opts;
+  private boolean opts_flag = false;
+  private Object oopts;
+  private boolean oopts_flag = false;
+  private List<Object> vopts;
+  private boolean vopts_flag = false;
+  private List<Object> voopts;
+  private boolean voopts_flag = false;
+  private Map<String, Object> dopts;
+  private boolean dopts_flag = false;
+  private Map<String, Object> doopts;
+  private boolean doopts_flag = false;
+  private Object nativeObject;
+
+  public TestClass() {}
+
+  public TestClass(
+      boolean b,
+      Boolean ob,
+      List<Boolean> vb,
+      List<Boolean> vob,
+      Map<String, Boolean> db,
+      Map<String, Boolean> dob,
+      int i,
+      Integer oi,
+      List<Boolean> vi,
+      List<Boolean> voi,
+      Map<String, Boolean> di,
+      Map<String, Boolean> doi,
+      int ui,
+      Integer oui,
+      List<Boolean> vui,
+      List<Boolean> voui,
+      Map<String, Boolean> dui,
+      Map<String, Boolean> doui,
+      long i64,
+      Long oi64,
+      List<Boolean> vi64,
+      List<Boolean> voi64,
+      Map<String, Boolean> di64,
+      Map<String, Boolean> doi64,
+      float fl,
+      Float ofl,
+      List<Boolean> vfl,
+      List<Boolean> vofl,
+      Map<String, Boolean> dfl,
+      Map<String, Boolean> dofl,
+      double d,
+      Double od,
+      List<Boolean> vd,
+      List<Boolean> vod,
+      Map<String, Boolean> dd,
+      Map<String, Boolean> dod,
+      String s,
+      String os,
+      List<Boolean> vs,
+      List<Boolean> vos,
+      Map<String, Boolean> ds,
+      Map<String, Boolean> dos,
+      long ti,
+      Long oti,
+      List<Boolean> vti,
+      List<Boolean> voti,
+      Map<String, Boolean> dti,
+      Map<String, Boolean> doti,
+      long at,
+      Long oat,
+      List<Boolean> vat,
+      List<Boolean> voat,
+      Map<String, Boolean> dat,
+      Map<String, Boolean> doat,
+      long rt,
+      Long ort,
+      List<Boolean> vrt,
+      List<Boolean> vort,
+      Map<String, Boolean> drt,
+      Map<String, Boolean> dort,
+      byte[] by,
+      byte[] oby,
+      int c,
+      Integer oc,
+      List<Integer> vc,
+      List<Integer> voc,
+      Map<String, Integer> dc,
+      Map<String, Integer> doc,
+      Object p,
+      Object op,
+      List<Object> vp,
+      List<Object> vop,
+      Map<String, Object> dp,
+      Map<String, Object> dop,
+      Object e,
+      Object oe,
+      List<Object> ve,
+      List<Object> voe,
+      Map<String, Object> de,
+      Map<String, Object> doe,
+      int be,
+      Integer obe,
+      List<Object> vbe,
+      List<Object> vobe,
+      Map<String, Object> dbe,
+      Map<String, Object> dobe,
+      Object ts,
+      Object ots,
+      List<Object> vts,
+      List<Object> vots,
+      Map<String, Object> dts,
+      Map<String, Object> dots,
+      Object lts,
+      Object olts,
+      List<Object> vlts,
+      List<Object> volts,
+      Map<String, Object> dlts,
+      Map<String, Object> dolts,
+      Object opts,
+      Object oopts,
+      List<Object> vopts,
+      List<Object> voopts,
+      Map<String, Object> dopts,
+      Map<String, Object> doopts) {
+    if (vb == null) {
+      throw new IllegalArgumentException("vb");
+    } else if (vob == null) {
+      throw new IllegalArgumentException("vob");
+    } else if (db == null) {
+      throw new IllegalArgumentException("db");
+    } else if (dob == null) {
+      throw new IllegalArgumentException("dob");
+    } else if (vi == null) {
+      throw new IllegalArgumentException("vi");
+    } else if (voi == null) {
+      throw new IllegalArgumentException("voi");
+    } else if (di == null) {
+      throw new IllegalArgumentException("di");
+    } else if (doi == null) {
+      throw new IllegalArgumentException("doi");
+    } else if (vui == null) {
+      throw new IllegalArgumentException("vui");
+    } else if (voui == null) {
+      throw new IllegalArgumentException("voui");
+    } else if (dui == null) {
+      throw new IllegalArgumentException("dui");
+    } else if (doui == null) {
+      throw new IllegalArgumentException("doui");
+    } else if (vi64 == null) {
+      throw new IllegalArgumentException("vi64");
+    } else if (voi64 == null) {
+      throw new IllegalArgumentException("voi64");
+    } else if (di64 == null) {
+      throw new IllegalArgumentException("di64");
+    } else if (doi64 == null) {
+      throw new IllegalArgumentException("doi64");
+    } else if (vfl == null) {
+      throw new IllegalArgumentException("vfl");
+    } else if (vofl == null) {
+      throw new IllegalArgumentException("vofl");
+    } else if (dfl == null) {
+      throw new IllegalArgumentException("dfl");
+    } else if (dofl == null) {
+      throw new IllegalArgumentException("dofl");
+    } else if (vd == null) {
+      throw new IllegalArgumentException("vd");
+    } else if (vod == null) {
+      throw new IllegalArgumentException("vod");
+    } else if (dd == null) {
+      throw new IllegalArgumentException("dd");
+    } else if (dod == null) {
+      throw new IllegalArgumentException("dod");
+    } else if (s == null) {
+      throw new IllegalArgumentException("s");
+    } else if (vs == null) {
+      throw new IllegalArgumentException("vs");
+    } else if (vos == null) {
+      throw new IllegalArgumentException("vos");
+    } else if (ds == null) {
+      throw new IllegalArgumentException("ds");
+    } else if (dos == null) {
+      throw new IllegalArgumentException("dos");
+    } else if (vti == null) {
+      throw new IllegalArgumentException("vti");
+    } else if (voti == null) {
+      throw new IllegalArgumentException("voti");
+    } else if (dti == null) {
+      throw new IllegalArgumentException("dti");
+    } else if (doti == null) {
+      throw new IllegalArgumentException("doti");
+    } else if (vat == null) {
+      throw new IllegalArgumentException("vat");
+    } else if (voat == null) {
+      throw new IllegalArgumentException("voat");
+    } else if (dat == null) {
+      throw new IllegalArgumentException("dat");
+    } else if (doat == null) {
+      throw new IllegalArgumentException("doat");
+    } else if (vrt == null) {
+      throw new IllegalArgumentException("vrt");
+    } else if (vort == null) {
+      throw new IllegalArgumentException("vort");
+    } else if (drt == null) {
+      throw new IllegalArgumentException("drt");
+    } else if (dort == null) {
+      throw new IllegalArgumentException("dort");
+    } else if (by == null) {
+      throw new IllegalArgumentException("by");
+    } else if (vc == null) {
+      throw new IllegalArgumentException("vc");
+    } else if (voc == null) {
+      throw new IllegalArgumentException("voc");
+    } else if (dc == null) {
+      throw new IllegalArgumentException("dc");
+    } else if (doc == null) {
+      throw new IllegalArgumentException("doc");
+    } else if (p == null) {
+      throw new IllegalArgumentException("p");
+    } else if (vp == null) {
+      throw new IllegalArgumentException("vp");
+    } else if (vop == null) {
+      throw new IllegalArgumentException("vop");
+    } else if (dp == null) {
+      throw new IllegalArgumentException("dp");
+    } else if (dop == null) {
+      throw new IllegalArgumentException("dop");
+    } else if (e == null) {
+      throw new IllegalArgumentException("e");
+    } else if (ve == null) {
+      throw new IllegalArgumentException("ve");
+    } else if (voe == null) {
+      throw new IllegalArgumentException("voe");
+    } else if (de == null) {
+      throw new IllegalArgumentException("de");
+    } else if (doe == null) {
+      throw new IllegalArgumentException("doe");
+    } else if (vbe == null) {
+      throw new IllegalArgumentException("vbe");
+    } else if (vobe == null) {
+      throw new IllegalArgumentException("vobe");
+    } else if (dbe == null) {
+      throw new IllegalArgumentException("dbe");
+    } else if (dobe == null) {
+      throw new IllegalArgumentException("dobe");
+    } else if (ts == null) {
+      throw new IllegalArgumentException("ts");
+    } else if (vts == null) {
+      throw new IllegalArgumentException("vts");
+    } else if (vots == null) {
+      throw new IllegalArgumentException("vots");
+    } else if (dts == null) {
+      throw new IllegalArgumentException("dts");
+    } else if (dots == null) {
+      throw new IllegalArgumentException("dots");
+    } else if (lts == null) {
+      throw new IllegalArgumentException("lts");
+    } else if (vlts == null) {
+      throw new IllegalArgumentException("vlts");
+    } else if (volts == null) {
+      throw new IllegalArgumentException("volts");
+    } else if (dlts == null) {
+      throw new IllegalArgumentException("dlts");
+    } else if (dolts == null) {
+      throw new IllegalArgumentException("dolts");
+    } else if (opts == null) {
+      throw new IllegalArgumentException("opts");
+    } else if (vopts == null) {
+      throw new IllegalArgumentException("vopts");
+    } else if (voopts == null) {
+      throw new IllegalArgumentException("voopts");
+    } else if (dopts == null) {
+      throw new IllegalArgumentException("dopts");
+    } else if (doopts == null) {
+      throw new IllegalArgumentException("doopts");
+    } else {
+      this.nativeObject =
+          this.init(
+              b, ob, vb, vob, db, dob, i, oi, vi, voi, di, doi, ui, oui, vui, voui, dui, doui, i64,
+              oi64, vi64, voi64, di64, doi64, fl, ofl, vfl, vofl, dfl, dofl, d, od, vd, vod, dd,
+              dod, s, os, vs, vos, ds, dos, ti, oti, vti, voti, dti, doti, at, oat, vat, voat, dat,
+              doat, rt, ort, vrt, vort, drt, dort, by, oby, c, oc, vc, voc, dc, doc, p, op, vp, vop,
+              dp, dop, e, oe, ve, voe, de, doe, be, obe, vbe, vobe, dbe, dobe, ts, ots, vts, vots,
+              dts, dots, lts, olts, vlts, volts, dlts, dolts, opts, oopts, vopts, voopts, dopts,
+              doopts);
+      this.b = b;
+      this.b_flag = true;
+      this.ob = ob;
+      this.ob_flag = true;
+      this.vb = vb;
+      this.vb_flag = true;
+      this.vob = vob;
+      this.vob_flag = true;
+      this.db = db;
+      this.db_flag = true;
+      this.dob = dob;
+      this.dob_flag = true;
+      this.i = i;
+      this.i_flag = true;
+      this.oi = oi;
+      this.oi_flag = true;
+      this.vi = vi;
+      this.vi_flag = true;
+      this.voi = voi;
+      this.voi_flag = true;
+      this.di = di;
+      this.di_flag = true;
+      this.doi = doi;
+      this.doi_flag = true;
+      this.ui = ui;
+      this.ui_flag = true;
+      this.oui = oui;
+      this.oui_flag = true;
+      this.vui = vui;
+      this.vui_flag = true;
+      this.voui = voui;
+      this.voui_flag = true;
+      this.dui = dui;
+      this.dui_flag = true;
+      this.doui = doui;
+      this.doui_flag = true;
+      this.i64 = i64;
+      this.i64_flag = true;
+      this.oi64 = oi64;
+      this.oi64_flag = true;
+      this.vi64 = vi64;
+      this.vi64_flag = true;
+      this.voi64 = voi64;
+      this.voi64_flag = true;
+      this.di64 = di64;
+      this.di64_flag = true;
+      this.doi64 = doi64;
+      this.doi64_flag = true;
+      this.fl = fl;
+      this.fl_flag = true;
+      this.ofl = ofl;
+      this.ofl_flag = true;
+      this.vfl = vfl;
+      this.vfl_flag = true;
+      this.vofl = vofl;
+      this.vofl_flag = true;
+      this.dfl = dfl;
+      this.dfl_flag = true;
+      this.dofl = dofl;
+      this.dofl_flag = true;
+      this.d = d;
+      this.d_flag = true;
+      this.od = od;
+      this.od_flag = true;
+      this.vd = vd;
+      this.vd_flag = true;
+      this.vod = vod;
+      this.vod_flag = true;
+      this.dd = dd;
+      this.dd_flag = true;
+      this.dod = dod;
+      this.dod_flag = true;
+      this.s = s;
+      this.s_flag = true;
+      this.os = os;
+      this.os_flag = true;
+      this.vs = vs;
+      this.vs_flag = true;
+      this.vos = vos;
+      this.vos_flag = true;
+      this.ds = ds;
+      this.ds_flag = true;
+      this.dos = dos;
+      this.dos_flag = true;
+      this.ti = ti;
+      this.ti_flag = true;
+      this.oti = oti;
+      this.oti_flag = true;
+      this.vti = vti;
+      this.vti_flag = true;
+      this.voti = voti;
+      this.voti_flag = true;
+      this.dti = dti;
+      this.dti_flag = true;
+      this.doti = doti;
+      this.doti_flag = true;
+      this.at = at;
+      this.at_flag = true;
+      this.oat = oat;
+      this.oat_flag = true;
+      this.vat = vat;
+      this.vat_flag = true;
+      this.voat = voat;
+      this.voat_flag = true;
+      this.dat = dat;
+      this.dat_flag = true;
+      this.doat = doat;
+      this.doat_flag = true;
+      this.rt = rt;
+      this.rt_flag = true;
+      this.ort = ort;
+      this.ort_flag = true;
+      this.vrt = vrt;
+      this.vrt_flag = true;
+      this.vort = vort;
+      this.vort_flag = true;
+      this.drt = drt;
+      this.drt_flag = true;
+      this.dort = dort;
+      this.dort_flag = true;
+      this.by = by;
+      this.by_flag = true;
+      this.oby = oby;
+      this.oby_flag = true;
+      this.c = c;
+      this.c_flag = true;
+      this.oc = oc;
+      this.oc_flag = true;
+      this.vc = vc;
+      this.vc_flag = true;
+      this.voc = voc;
+      this.voc_flag = true;
+      this.dc = dc;
+      this.dc_flag = true;
+      this.doc = doc;
+      this.doc_flag = true;
+      this.p = p;
+      this.p_flag = true;
+      this.op = op;
+      this.op_flag = true;
+      this.vp = vp;
+      this.vp_flag = true;
+      this.vop = vop;
+      this.vop_flag = true;
+      this.dp = dp;
+      this.dp_flag = true;
+      this.dop = dop;
+      this.dop_flag = true;
+      this.e = e;
+      this.e_flag = true;
+      this.oe = oe;
+      this.oe_flag = true;
+      this.ve = ve;
+      this.ve_flag = true;
+      this.voe = voe;
+      this.voe_flag = true;
+      this.de = de;
+      this.de_flag = true;
+      this.doe = doe;
+      this.doe_flag = true;
+      this.be = be;
+      this.be_flag = true;
+      this.obe = obe;
+      this.obe_flag = true;
+      this.vbe = vbe;
+      this.vbe_flag = true;
+      this.vobe = vobe;
+      this.vobe_flag = true;
+      this.dbe = dbe;
+      this.dbe_flag = true;
+      this.dobe = dobe;
+      this.dobe_flag = true;
+      this.ts = ts;
+      this.ts_flag = true;
+      this.ots = ots;
+      this.ots_flag = true;
+      this.vts = vts;
+      this.vts_flag = true;
+      this.vots = vots;
+      this.vots_flag = true;
+      this.dts = dts;
+      this.dts_flag = true;
+      this.dots = dots;
+      this.dots_flag = true;
+      this.lts = lts;
+      this.lts_flag = true;
+      this.olts = olts;
+      this.olts_flag = true;
+      this.vlts = vlts;
+      this.vlts_flag = true;
+      this.volts = volts;
+      this.volts_flag = true;
+      this.dlts = dlts;
+      this.dlts_flag = true;
+      this.dolts = dolts;
+      this.dolts_flag = true;
+      this.opts = opts;
+      this.opts_flag = true;
+      this.oopts = oopts;
+      this.oopts_flag = true;
+      this.vopts = vopts;
+      this.vopts_flag = true;
+      this.voopts = voopts;
+      this.voopts_flag = true;
+      this.dopts = dopts;
+      this.dopts_flag = true;
+      this.doopts = doopts;
+      this.doopts_flag = true;
+    }
+  }
+
+  private native Object init(
+      boolean v1,
+      Boolean v2,
+      List<Boolean> v3,
+      List<Boolean> v4,
+      Map<String, Boolean> v5,
+      Map<String, Boolean> v6,
+      int v7, Integer var8,
+      List<Boolean> v9,
+      List<Boolean> v10,
+      Map<String, Boolean> v11,
+      Map<String, Boolean> v12,
+      int v13,
+      Integer v14,
+      List<Boolean> v15,
+      List<Boolean> v16,
+      Map<String, Boolean> v17,
+      Map<String, Boolean> v18,
+      long v19, Long var21,
+      List<Boolean> v22,
+      List<Boolean> v23,
+      Map<String, Boolean> v24,
+      Map<String, Boolean> v25,
+      float v26,
+      Float v27,
+      List<Boolean> v28,
+      List<Boolean> v29,
+      Map<String, Boolean> v30,
+      Map<String, Boolean> v31,
+      double v32,
+      Double v34,
+      List<Boolean> v35,
+      List<Boolean> v36,
+      Map<String, Boolean> v37,
+      Map<String, Boolean> v38,
+      String v39,
+      String v40,
+      List<Boolean> v41,
+      List<Boolean> v42,
+      Map<String, Boolean> v43,
+      Map<String, Boolean> v44,
+      long v45, Long var47,
+      List<Boolean> v48,
+      List<Boolean> v49,
+      Map<String, Boolean> v50,
+      Map<String, Boolean> v51,
+      long v52,
+      Long v54,
+      List<Boolean> v55,
+      List<Boolean> v56,
+      Map<String, Boolean> v57,
+      Map<String, Boolean> v58,
+      long v59,
+      Long v61,
+      List<Boolean> v62,
+      List<Boolean> v63,
+      Map<String, Boolean> v64,
+      Map<String, Boolean> v65,
+      byte[] v66,
+      byte[] v67,
+      int v68,
+      Integer v69,
+      List<Integer> v70,
+      List<Integer> v71,
+      Map<String, Integer> v72,
+      Map<String, Integer> v73,
+      Object v74,
+      Object v75,
+      List<Object> v76,
+      List<Object> v77,
+      Map<String, Object> v78,
+      Map<String, Object> v79,
+      Object v80,
+      Object v81,
+      List<Object> v82,
+      List<Object> v83,
+      Map<String, Object> v84,
+      Map<String, Object> v85,
+      int v86,
+      Integer v87,
+      List<Object> v88,
+      List<Object> v89,
+      Map<String, Object> v90,
+      Map<String, Object> v91,
+      Object v92,
+      Object v93,
+      List<Object> v94,
+      List<Object> v95,
+      Map<String, Object> v96,
+      Map<String, Object> v97,
+      Object v98,
+      Object v99,
+      List<Object> v100,
+      List<Object> v101,
+      Map<String, Object> v102,
+      Map<String, Object> v103,
+      Object v104,
+      Object v105,
+      List<Object> v106,
+      List<Object> v107,
+      Map<String, Object> v108,
+      Map<String, Object> v109);
+}
diff --git a/src/test/java/com/android/tools/r8/naming/InterfaceRenamingTestRunner.java b/src/test/java/com/android/tools/r8/naming/InterfaceRenamingTestRunner.java
index d25c061..6c054e5 100644
--- a/src/test/java/com/android/tools/r8/naming/InterfaceRenamingTestRunner.java
+++ b/src/test/java/com/android/tools/r8/naming/InterfaceRenamingTestRunner.java
@@ -24,7 +24,6 @@
 public class InterfaceRenamingTestRunner extends TestBase {
   static final Class CLASS = InterfaceRenamingTest.class;
   static final Class[] CLASSES = InterfaceRenamingTest.CLASSES;
-  private boolean bug = false;
 
   @Test
   public void testCfNoMinify() throws Exception {
@@ -33,7 +32,6 @@
 
   @Test
   public void testCfMinify() throws Exception {
-    bug = true;
     testCf(MinifyMode.JAVA);
   }
 
@@ -49,7 +47,6 @@
 
   @Test
   public void testDexMinify() throws Exception {
-    bug = true;
     testDex(MinifyMode.JAVA);
   }
 
@@ -65,11 +62,6 @@
     Path outCf = temp.getRoot().toPath().resolve("cf.zip");
     build(new ClassFileConsumer.ArchiveConsumer(outCf), minify);
     ProcessResult runCf = ToolHelper.runJava(outCf, CLASS.getCanonicalName());
-    if (bug) {
-      assertNotEquals(-1, runCf.stderr.indexOf("java.lang.AbstractMethodError"));
-      assertNotEquals(0, runCf.exitCode);
-      return;
-    }
     assertEquals(runInput.toString(), runCf.toString());
   }
 
@@ -79,12 +71,6 @@
     assertEquals(0, runInput.exitCode);
     Path outDex = temp.getRoot().toPath().resolve("dex.zip");
     build(new DexIndexedConsumer.ArchiveConsumer(outDex), minify);
-    if (bug) {
-      ProcessResult runDex = ToolHelper.runArtRaw(outDex.toString(), CLASS.getCanonicalName());
-      assertNotEquals(-1, runDex.stderr.indexOf("java.lang.AbstractMethodError"));
-      assertNotEquals(0, runDex.exitCode);
-      return;
-    }
     ProcessResult runDex =
         ToolHelper.runArtNoVerificationErrorsRaw(outDex.toString(), CLASS.getCanonicalName());
     assertEquals(runInput.stdout, runDex.stdout);