diff --git a/build.gradle b/build.gradle
index f379bbf..8ea2b3f 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1239,6 +1239,18 @@
 }
 
 test {
+    if (project.hasProperty('generate_golden_files_to')) {
+        systemProperty 'generate_golden_files_to', project.property('generate_golden_files_to')
+        assert project.hasProperty('HEAD_sha1')
+        systemProperty 'test_git_HEAD_sha1', project.property('HEAD_sha1')
+    }
+
+    if (project.hasProperty('use_golden_files_in')) {
+        systemProperty 'use_golden_files_in', project.property('use_golden_files_in')
+        assert project.hasProperty('HEAD_sha1')
+        systemProperty 'test_git_HEAD_sha1', project.property('HEAD_sha1')
+    }
+
     dependsOn getJarsFromSupportLibs
     testLogging.exceptionFormat = 'full'
     if (project.hasProperty('print_test_stdout')) {
diff --git a/src/main/java/com/android/tools/r8/Disassemble.java b/src/main/java/com/android/tools/r8/Disassemble.java
index 4f64416..9b1599f 100644
--- a/src/main/java/com/android/tools/r8/Disassemble.java
+++ b/src/main/java/com/android/tools/r8/Disassemble.java
@@ -161,6 +161,7 @@
     InternalOptions getInternalOptions() {
       InternalOptions internal = new InternalOptions();
       internal.useSmaliSyntax = useSmali;
+      internal.enableCfFrontend = true;
       return internal;
     }
   }
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 f907ffb..66664e6 100644
--- a/src/main/java/com/android/tools/r8/cf/CfPrinter.java
+++ b/src/main/java/com/android/tools/r8/cf/CfPrinter.java
@@ -59,6 +59,8 @@
 import com.android.tools.r8.ir.code.NumericType;
 import com.android.tools.r8.ir.code.Position;
 import com.android.tools.r8.ir.code.ValueType;
+import com.android.tools.r8.naming.ClassNameMapper;
+import com.android.tools.r8.naming.MemberNaming.MethodSignature;
 import com.android.tools.r8.utils.DescriptorUtils;
 import it.unimi.dsi.fastutil.ints.Int2ReferenceMap.Entry;
 import it.unimi.dsi.fastutil.ints.IntList;
@@ -80,15 +82,18 @@
   private final Map<CfLabel, String> labels;
 
   private final StringBuilder builder = new StringBuilder();
+  private final ClassNameMapper mapper;
 
   /** Entry for printing single instructions without global knowledge (eg, label numbers). */
   public CfPrinter() {
     indent = "";
     labels = null;
+    mapper = null;
   }
 
   /** Entry for printing a complete code object. */
-  public CfPrinter(CfCode code) {
+  public CfPrinter(CfCode code, ClassNameMapper mapper) {
+    this.mapper = mapper;
     indent = "  ";
     labels = new HashMap<>();
     int nextLabelNumber = 0;
@@ -284,12 +289,13 @@
   }
 
   public void print(CfFrame frame) {
-    StringBuilder builder = new StringBuilder("frame: [");
+    indent();
+    builder.append("; frame: [");
     {
       String separator = "";
       for (Entry<FrameType> entry : frame.getLocals().int2ReferenceEntrySet()) {
         builder.append(separator).append(entry.getIntKey()).append(':');
-        print(entry.getValue(), builder);
+        print(entry.getValue());
         separator = ", ";
       }
     }
@@ -298,17 +304,18 @@
       String separator = "";
       for (FrameType element : frame.getStack()) {
         builder.append(separator);
-        print(element, builder);
+        print(element);
         separator = ", ";
       }
     }
     builder.append(']');
-    comment(builder.toString());
   }
 
-  private void print(FrameType type, StringBuilder builder) {
+  private void print(FrameType type) {
     if (type.isUninitializedNew()) {
       builder.append("uninitialized ").append(getLabel(type.getUninitializedLabel()));
+    } else if (type.isInitialized()) {
+      appendType(type.getInitializedType());
     } else {
       builder.append(type.toString());
     }
@@ -566,19 +573,50 @@
   }
 
   private void appendDescriptor(DexType type) {
+    if (mapper != null) {
+      builder.append(DescriptorUtils.javaTypeToDescriptor(mapper.originalNameOf(type)));
+      return;
+    }
     builder.append(type.toDescriptorString());
   }
 
+  private void appendType(DexType type) {
+    if (type.isArrayType() || type.isClassType()) {
+      appendClass(type);
+    } else {
+      builder.append(type);
+    }
+  }
+
   private void appendClass(DexType type) {
-    builder.append(type.getInternalName());
+    assert type.isArrayType() || type.isClassType();
+    if (mapper == null) {
+      builder.append(type.getInternalName());
+    } else if (type == DexItemFactory.nullValueType) {
+      builder.append("NULL");
+    } else {
+      builder.append(
+          DescriptorUtils.descriptorToInternalName(
+              DescriptorUtils.javaTypeToDescriptor(mapper.originalNameOf(type))));
+    }
   }
 
   private void appendField(DexField field) {
+    if (mapper != null) {
+      builder.append(mapper.originalSignatureOf(field).toString());
+      return;
+    }
     appendClass(field.getHolder());
     builder.append('/').append(field.name);
   }
 
   private void appendMethod(DexMethod method) {
+    if (mapper != null) {
+      MethodSignature signature = (MethodSignature) mapper.originalSignatureOf(method);
+      builder.append(mapper.originalNameOf(method.holder)).append('.');
+      builder.append(signature.name).append(signature.toDescriptor());
+      return;
+    }
     builder.append(method.qualifiedName());
     builder.append(method.proto.toDescriptorString());
   }
diff --git a/src/main/java/com/android/tools/r8/graph/AssemblyWriter.java b/src/main/java/com/android/tools/r8/graph/AssemblyWriter.java
index 63a2958..89abadd 100644
--- a/src/main/java/com/android/tools/r8/graph/AssemblyWriter.java
+++ b/src/main/java/com/android/tools/r8/graph/AssemblyWriter.java
@@ -79,7 +79,7 @@
   void writeMethod(DexEncodedMethod method, PrintStream ps) {
     ClassNameMapper naming = application.getProguardMap();
     String methodName = naming != null
-        ? naming.originalSignatureOf(method.method).toString()
+        ? naming.originalSignatureOf(method.method).name
         : method.method.name.toString();
     ps.println("#");
     ps.println("# Method: '" + methodName + "':");
diff --git a/src/main/java/com/android/tools/r8/graph/CfCode.java b/src/main/java/com/android/tools/r8/graph/CfCode.java
index 1fd4a73..ffa34d1 100644
--- a/src/main/java/com/android/tools/r8/graph/CfCode.java
+++ b/src/main/java/com/android/tools/r8/graph/CfCode.java
@@ -251,11 +251,11 @@
 
   @Override
   public String toString() {
-    return new CfPrinter(this).toString();
+    return new CfPrinter(this, null).toString();
   }
 
   @Override
   public String toString(DexEncodedMethod method, ClassNameMapper naming) {
-    return null;
+    return new CfPrinter(this, naming).toString();
   }
 }
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 9f97f88..831edbe 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
@@ -43,12 +43,9 @@
 import com.android.tools.r8.naming.NamingLens;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.utils.InternalOptions;
-import com.google.common.collect.ImmutableMap;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
-import java.util.Map;
-import java.util.Set;
 import java.util.function.Consumer;
 
 public class DexEncodedMethod extends KeyedDexItem<DexMethod> implements ResolutionResult {
@@ -582,6 +579,14 @@
     return m1.method.slowCompareTo(m2.method);
   }
 
+  public static class ClassInlinerEligibility {
+    public final boolean returnsReceiver;
+
+    public ClassInlinerEligibility(boolean returnsReceiver) {
+      this.returnsReceiver = returnsReceiver;
+    }
+  }
+
   public static class OptimizationInfo {
 
     private int returnedArgument = -1;
@@ -593,8 +598,9 @@
     private boolean useIdentifierNameString = false;
     private boolean checksNullReceiverBeforeAnySideEffect = false;
     private boolean triggersClassInitBeforeAnySideEffect = false;
-    private Set<DexField> receiverOnlyUsedForReadingFields = null;
-    private Map<DexField, Integer> onlyInitializesFieldsWithNoOtherSideEffects = null;
+    // Stores information about instance methods and constructors for
+    // class inliner, null value indicates that the method is not eligible.
+    private ClassInlinerEligibility classInlinerEligibility = null;
 
     private OptimizationInfo() {
       // Intentionally left empty.
@@ -631,13 +637,12 @@
       return returnsConstant;
     }
 
-    public boolean isReceiverOnlyUsedForReadingFields(Set<DexField> fields) {
-      return receiverOnlyUsedForReadingFields != null &&
-          fields.containsAll(receiverOnlyUsedForReadingFields);
+    private void setClassInlinerEligibility(ClassInlinerEligibility eligibility) {
+      this.classInlinerEligibility = eligibility;
     }
 
-    public Map<DexField, Integer> onlyInitializesFieldsWithNoOtherSideEffects() {
-      return onlyInitializesFieldsWithNoOtherSideEffects;
+    public ClassInlinerEligibility getClassInlinerEligibility() {
+      return this.classInlinerEligibility;
     }
 
     public long getReturnedConstant() {
@@ -681,19 +686,6 @@
       returnedConstant = value;
     }
 
-    private void markReceiverOnlyUsedForReadingFields(Set<DexField> fields) {
-      receiverOnlyUsedForReadingFields = fields;
-    }
-
-    private void markOnlyInitializesFieldsWithNoOtherSideEffects(Map<DexField, Integer> mapping) {
-      if (mapping == null) {
-        onlyInitializesFieldsWithNoOtherSideEffects = null;
-      } else {
-        onlyInitializesFieldsWithNoOtherSideEffects = mapping.isEmpty()
-            ? Collections.emptyMap() : ImmutableMap.copyOf(mapping);
-      }
-    }
-
     private void markForceInline() {
       forceInline = true;
     }
@@ -751,13 +743,8 @@
     ensureMutableOI().markReturnsConstant(value);
   }
 
-  synchronized public void markReceiverOnlyUsedForReadingFields(Set<DexField> fields) {
-    ensureMutableOI().markReceiverOnlyUsedForReadingFields(fields);
-  }
-
-  synchronized public void markOnlyInitializesFieldsWithNoOtherSideEffects(
-      Map<DexField, Integer> mapping) {
-    ensureMutableOI().markOnlyInitializesFieldsWithNoOtherSideEffects(mapping);
+  synchronized public void setClassInlinerEligibility(ClassInlinerEligibility eligibility) {
+    ensureMutableOI().setClassInlinerEligibility(eligibility);
   }
 
   synchronized public void markForceInline() {
diff --git a/src/main/java/com/android/tools/r8/graph/LazyCfCode.java b/src/main/java/com/android/tools/r8/graph/LazyCfCode.java
index 8ecc1ab..454ed29 100644
--- a/src/main/java/com/android/tools/r8/graph/LazyCfCode.java
+++ b/src/main/java/com/android/tools/r8/graph/LazyCfCode.java
@@ -203,7 +203,7 @@
 
   @Override
   public String toString(DexEncodedMethod method, ClassNameMapper naming) {
-    return null;
+    return asCfCode().toString(method, naming);
   }
 
   private static class ClassCodeVisitor extends ClassVisitor {
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 186839b..51850a0 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
@@ -76,6 +76,10 @@
   }
 
   public void addOperands(List<Value> operands) {
+    addOperands(operands, true);
+  }
+
+  public void addOperands(List<Value> operands, boolean removeTrivialPhi) {
     // Phi operands are only filled in once to complete the phi. Some phis are incomplete for a
     // period of time to break cycles. When the cycle has been resolved they are completed
     // exactly once by adding the operands.
@@ -91,7 +95,9 @@
     if (!canBeNull) {
       markNeverNull();
     }
-    removeTrivialPhi();
+    if (removeTrivialPhi) {
+      removeTrivialPhi();
+    }
   }
 
   public void addDebugValue(Value value) {
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 306d7a1..81dc436 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
@@ -169,7 +169,8 @@
     }
     this.classInliner =
         (options.enableClassInlining && options.enableInlining && inliner != null)
-            ? new ClassInliner(appInfo.dexItemFactory) : null;
+            ? new ClassInliner(appInfo.dexItemFactory, options.classInliningInstructionLimit)
+            : null;
   }
 
   /**
@@ -756,10 +757,7 @@
     }
 
     // Analysis must be done after method is rewritten by logArgumentTypes()
-    codeRewriter.identifyReceiverOnlyUsedForReadingFields(method, code, feedback);
-    if (method.isInstanceInitializer()) {
-      codeRewriter.identifyOnlyInitializesFieldsWithNoOtherSideEffects(method, code, feedback);
-    }
+    codeRewriter.identifyClassInlinerEligibility(method, code, feedback);
 
     printMethod(code, "Optimized IR (SSA)");
     finalizeIR(method, code, feedback);
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
index 26ca6b2..16a77c8 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedback.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedback.java
@@ -5,10 +5,8 @@
 package com.android.tools.r8.ir.conversion;
 
 import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexEncodedMethod.ClassInlinerEligibility;
 import com.android.tools.r8.ir.optimize.Inliner.Constraint;
-import java.util.Map;
-import java.util.Set;
 
 public interface OptimizationFeedback {
   void methodReturnsArgument(DexEncodedMethod method, int argument);
@@ -18,7 +16,5 @@
   void markProcessed(DexEncodedMethod method, Constraint state);
   void markCheckNullReceiverBeforeAnySideEffect(DexEncodedMethod method, boolean mark);
   void markTriggerClassInitBeforeAnySideEffect(DexEncodedMethod method, boolean mark);
-  void markReceiverOnlyUsedForReadingFields(DexEncodedMethod method, Set<DexField> fields);
-  void markOnlyInitializesFieldsWithNoOtherSideEffects(
-      DexEncodedMethod method, Map<DexField, Integer> mapping);
+  void setClassInlinerEligibility(DexEncodedMethod method, ClassInlinerEligibility eligibility);
 }
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
index 645df64..7303b6b 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackDirect.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackDirect.java
@@ -5,10 +5,8 @@
 package com.android.tools.r8.ir.conversion;
 
 import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexEncodedMethod.ClassInlinerEligibility;
 import com.android.tools.r8.ir.optimize.Inliner.Constraint;
-import java.util.Map;
-import java.util.Set;
 
 public class OptimizationFeedbackDirect implements OptimizationFeedback {
 
@@ -48,13 +46,8 @@
   }
 
   @Override
-  public void markReceiverOnlyUsedForReadingFields(DexEncodedMethod method, Set<DexField> fields) {
-    method.markReceiverOnlyUsedForReadingFields(fields);
-  }
-
-  @Override
-  public void markOnlyInitializesFieldsWithNoOtherSideEffects(DexEncodedMethod method,
-      Map<DexField, Integer> mapping) {
-    method.markOnlyInitializesFieldsWithNoOtherSideEffects(mapping);
+  public void setClassInlinerEligibility(
+      DexEncodedMethod method, ClassInlinerEligibility eligibility) {
+    method.setClassInlinerEligibility(eligibility);
   }
 }
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
index 97fe052..6915a2f 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackIgnore.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackIgnore.java
@@ -5,10 +5,8 @@
 package com.android.tools.r8.ir.conversion;
 
 import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexEncodedMethod.ClassInlinerEligibility;
 import com.android.tools.r8.ir.optimize.Inliner.Constraint;
-import java.util.Map;
-import java.util.Set;
 
 public class OptimizationFeedbackIgnore implements OptimizationFeedback {
 
@@ -34,11 +32,7 @@
   public void markTriggerClassInitBeforeAnySideEffect(DexEncodedMethod method, boolean mark) {}
 
   @Override
-  public void markReceiverOnlyUsedForReadingFields(DexEncodedMethod method, Set<DexField> fields) {
-  }
-
-  @Override
-  public void markOnlyInitializesFieldsWithNoOtherSideEffects(DexEncodedMethod method,
-      Map<DexField, Integer> mapping) {
+  public void setClassInlinerEligibility(
+      DexEncodedMethod method, ClassInlinerEligibility eligibility) {
   }
 }
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 6ab4845..bd3442c 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
@@ -12,6 +12,7 @@
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexEncodedMethod.ClassInlinerEligibility;
 import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexMethod;
@@ -47,8 +48,6 @@
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.If;
 import com.android.tools.r8.ir.code.If.Type;
-import com.android.tools.r8.ir.code.InstanceGet;
-import com.android.tools.r8.ir.code.InstancePut;
 import com.android.tools.r8.ir.code.Instruction;
 import com.android.tools.r8.ir.code.InstructionIterator;
 import com.android.tools.r8.ir.code.InstructionListIterator;
@@ -740,120 +739,72 @@
     }
   }
 
-  public void identifyReceiverOnlyUsedForReadingFields(
+  public void identifyClassInlinerEligibility(
       DexEncodedMethod method, IRCode code, OptimizationFeedback feedback) {
-    if (!method.isNonAbstractVirtualMethod()) {
+    // Method eligibility is calculated in similar way for regular method
+    // and for the constructor. To be eligible method should only be using its
+    // receiver in the following ways:
+    //
+    //  (1) as a receiver of reads/writes of instance fields of the holder class
+    //  (2) as a return value
+    //  (3) as a receiver of a call to the superclass initializer
+    //
+    boolean instanceInitializer = method.isInstanceInitializer();
+    if (method.accessFlags.isNative() ||
+        (!method.isNonAbstractVirtualMethod() && !instanceInitializer)) {
       return;
     }
 
-    feedback.markReceiverOnlyUsedForReadingFields(method, null);
+    feedback.setClassInlinerEligibility(method, null);  // To allow returns below.
 
-    Value instance = code.getThis();
-    if (instance.numberOfPhiUsers() > 0) {
-      return;
-    }
-
-    Set<DexField> fields = Sets.newIdentityHashSet();
-    for (Instruction insn : instance.uniqueUsers()) {
-      if (!insn.isInstanceGet()) {
-        return;
-      }
-      InstanceGet get = insn.asInstanceGet();
-      if (get.dest() == instance || get.object() != instance) {
-        return;
-      }
-      fields.add(get.getField());
-    }
-    feedback.markReceiverOnlyUsedForReadingFields(method, fields);
-  }
-
-  public void identifyOnlyInitializesFieldsWithNoOtherSideEffects(
-      DexEncodedMethod method, IRCode code, OptimizationFeedback feedback) {
-    assert method.isInstanceInitializer();
-
-    feedback.markOnlyInitializesFieldsWithNoOtherSideEffects(method, null);
-
-    if (code.hasCatchHandlers()) {
-      return;
-    }
-
-    List<Value> args = code.collectArguments(true /* not interested in receiver */);
-    Map<DexField, Integer> mapping = new IdentityHashMap<>();
     Value receiver = code.getThis();
-
-    InstructionIterator it = code.instructionIterator();
-    while (it.hasNext()) {
-      Instruction instruction = it.next();
-
-      // Mark an argument.
-      if (instruction.isArgument()) {
-        continue;
-      }
-
-      // Allow super call to java.lang.Object.<init>() on 'this'.
-      if (instruction.isInvokeDirect()) {
-        InvokeDirect invokedDirect = instruction.asInvokeDirect();
-        if (invokedDirect.getInvokedMethod() != dexItemFactory.objectMethods.constructor ||
-            invokedDirect.getReceiver() != receiver) {
-          return;
-        }
-        continue;
-      }
-
-      // Allow final return.
-      if (instruction.isReturn()) {
-        continue;
-      }
-
-      // Allow assignment to this class' fields. If the assigned value is an argument
-      // reference update the mep. Otherwise just allow assigning any value, since all
-      // invalid values should be filtered out at the definitions.
-      if (instruction.isInstancePut()) {
-        InstancePut instancePut = instruction.asInstancePut();
-        DexField field = instancePut.getField();
-        if (instancePut.object() != receiver) {
-          return;
-        }
-
-        Value value = instancePut.value();
-        if (value.isArgument() && !value.isThis()) {
-          assert (args.contains(value));
-          mapping.put(field, args.indexOf(value));
-        } else {
-          mapping.remove(field);
-        }
-        continue;
-      }
-
-      // Allow non-throwing constants.
-      if (instruction.isConstInstruction()) {
-        if (instruction.instructionTypeCanThrow()) {
-          return;
-        }
-        continue;
-      }
-
-      // Allow goto instructions jumping to the next block.
-      if (instruction.isGoto()) {
-        if (instruction.getBlock().getNumber() + 1 !=
-            instruction.asGoto().getTarget().getNumber()) {
-          return;
-        }
-        continue;
-      }
-
-      // Allow binary and unary instructions if they don't throw.
-      if (instruction.isBinop() || instruction.isUnop()) {
-        if (instruction.instructionTypeCanThrow()) {
-          return;
-        }
-        continue;
-      }
-
+    if (receiver.numberOfPhiUsers() > 0) {
       return;
     }
 
-    feedback.markOnlyInitializesFieldsWithNoOtherSideEffects(method, mapping);
+    boolean receiverUsedAsReturnValue = false;
+    boolean seenSuperInitCall = false;
+    for (Instruction insn : receiver.uniqueUsers()) {
+      if (insn.isReturn()) {
+        receiverUsedAsReturnValue = true;
+        continue;
+      }
+
+      if (insn.isInstanceGet() ||
+          (insn.isInstancePut() && insn.asInstancePut().object() == receiver)) {
+        DexField field = insn.asFieldInstruction().getField();
+        if (field.clazz == method.method.holder) {
+          // Since class inliner currently only supports classes directly extending
+          // java.lang.Object, we don't need to worry about fields defined in superclasses.
+          continue;
+        }
+        return;
+      }
+
+      // If this is an instance initializer allow one call
+      // to java.lang.Object.<init>() on 'this'.
+      if (instanceInitializer && insn.isInvokeDirect()) {
+        InvokeDirect invokedDirect = insn.asInvokeDirect();
+        if (invokedDirect.getInvokedMethod() == dexItemFactory.objectMethods.constructor &&
+            invokedDirect.getReceiver() == receiver &&
+            !seenSuperInitCall) {
+          seenSuperInitCall = true;
+          continue;
+        }
+        return;
+      }
+
+      // Other receiver usages make the method not eligible.
+      return;
+    }
+
+    if (instanceInitializer && !seenSuperInitCall) {
+      // Call to super constructor not found?
+      return;
+    }
+
+    feedback.setClassInlinerEligibility(
+        method, new ClassInlinerEligibility(receiverUsedAsReturnValue));
   }
 
   /**
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/ConstantCanonicalizer.java b/src/main/java/com/android/tools/r8/ir/optimize/ConstantCanonicalizer.java
index 7a6a846..92bda1d 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/ConstantCanonicalizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/ConstantCanonicalizer.java
@@ -86,6 +86,7 @@
           });
     }
 
+    code.removeAllTrivialPhis();
     assert code.isConsistentSSA();
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java b/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
index 845e17b..01dcf0d 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/DefaultInliningOracle.java
@@ -315,6 +315,12 @@
   }
 
   @Override
+  public boolean isValidTarget(InvokeMethod invoke, DexEncodedMethod target, IRCode inlinee) {
+    return !target.isInstanceInitializer()
+        || inliner.legalConstructorInline(method, invoke, inlinee);
+  }
+
+  @Override
   public boolean exceededAllowance() {
     return instructionAllowance < 0;
   }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/ForcedInliningOracle.java b/src/main/java/com/android/tools/r8/ir/optimize/ForcedInliningOracle.java
index 86d40d9..b56dc21 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/ForcedInliningOracle.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/ForcedInliningOracle.java
@@ -61,6 +61,11 @@
   }
 
   @Override
+  public boolean isValidTarget(InvokeMethod invoke, DexEncodedMethod target, IRCode inlinee) {
+    return true;
+  }
+
+  @Override
   public ListIterator<BasicBlock> updateTypeInformationIfNeeded(IRCode inlinee,
       ListIterator<BasicBlock> blockIterator, BasicBlock block, BasicBlock invokeSuccessor) {
     return blockIterator;
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 b75597d..25cd969 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
@@ -285,7 +285,7 @@
     return numOfInstructions;
   }
 
-  private boolean legalConstructorInline(DexEncodedMethod method,
+  boolean legalConstructorInline(DexEncodedMethod method,
       InvokeMethod invoke, IRCode code) {
 
     // In the Java VM Specification section "4.10.2.4. Instance Initialization Methods and
@@ -447,8 +447,7 @@
 
               // Make sure constructor inlining is legal.
               assert !target.isClassInitializer();
-              if (target.isInstanceInitializer()
-                  && !legalConstructorInline(method, invoke, inlinee)) {
+              if (!strategy.isValidTarget(invoke, target, inlinee)) {
                 continue;
               }
               DexType downcast = createDowncastIfNeeded(strategy, invoke, target);
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/InliningStrategy.java b/src/main/java/com/android/tools/r8/ir/optimize/InliningStrategy.java
index 7b88b38..2443d11 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/InliningStrategy.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/InliningStrategy.java
@@ -18,6 +18,8 @@
 
   void ensureMethodProcessed(DexEncodedMethod target, IRCode inlinee);
 
+  boolean isValidTarget(InvokeMethod invoke, DexEncodedMethod target, IRCode inlinee);
+
   ListIterator<BasicBlock> updateTypeInformationIfNeeded(IRCode inlinee,
       ListIterator<BasicBlock> blockIterator, BasicBlock block, BasicBlock invokeSuccessor);
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java
index 9ff44eb..7bdff33 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java
@@ -9,68 +9,75 @@
 import com.android.tools.r8.graph.AppInfoWithSubtyping;
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexEncodedMethod.ClassInlinerEligibility;
 import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.code.BasicBlock;
+import com.android.tools.r8.ir.code.ConstNumber;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.InstanceGet;
 import com.android.tools.r8.ir.code.Instruction;
+import com.android.tools.r8.ir.code.InstructionListIterator;
 import com.android.tools.r8.ir.code.InvokeDirect;
 import com.android.tools.r8.ir.code.InvokeMethodWithReceiver;
 import com.android.tools.r8.ir.code.NewInstance;
+import com.android.tools.r8.ir.code.Phi;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.code.ValueType;
 import com.android.tools.r8.ir.optimize.Inliner.InliningInfo;
 import com.android.tools.r8.ir.optimize.Inliner.Reason;
 import com.google.common.collect.Streams;
-import java.util.Collections;
+import java.util.ArrayList;
 import java.util.IdentityHashMap;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
+import java.util.Map.Entry;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
 public final class ClassInliner {
   private final DexItemFactory factory;
+  private final int totalMethodInstructionLimit;
   private final ConcurrentHashMap<DexType, Boolean> knownClasses = new ConcurrentHashMap<>();
 
-  private static final Map<DexField, Integer> NO_MAPPING = new IdentityHashMap<>();
-
   public interface InlinerAction {
     void inline(Map<InvokeMethodWithReceiver, InliningInfo> methods);
   }
 
-  public ClassInliner(DexItemFactory factory) {
+  public ClassInliner(DexItemFactory factory, int totalMethodInstructionLimit) {
     this.factory = factory;
+    this.totalMethodInstructionLimit = totalMethodInstructionLimit;
   }
 
   // Process method code and inline eligible class instantiations, in short:
   //
   // - collect all 'new-instance' instructions in the original code. Note that class
-  // inlining, if happens, mutates code and can add 'new-instance' instructions.
-  // Processing them as well is possible, but does not seem to have much value.
+  // inlining, if happens, mutates code and may add new 'new-instance' instructions.
+  // Processing them as well is possible, but does not seem to bring much value.
   //
   // - for each 'new-instance' we check if it is eligible for inlining, i.e:
   //     -> the class of the new instance is 'eligible' (see computeClassEligible(...))
-  //     -> the instance is initialized with 'eligible' constructor (see
-  //        onlyInitializesFieldsWithNoOtherSideEffects flag in method's optimization
-  //        info); eligible constructor also defines a set of instance fields directly
-  //        initialized with parameter values, called field initialization mapping below
+  //     -> the instance is initialized with 'eligible' constructor (see comments in
+  //        CodeRewriter::identifyClassInlinerEligibility(...))
   //     -> has only 'eligible' uses, i.e:
-  //          * it is a receiver of a field read if the field is present in the
-  //            field initialization mapping
-  //          * it is a receiver of virtual or interface call with single target being
-  //            a method only reading fields in the current field initialization mapping
+  //          * as a receiver of a field read/write for a field defined in same class
+  //            as method.
+  //          * as a receiver of virtual or interface call with single target being
+  //            an eligible method according to identifyClassInlinerEligibility(...);
+  //            NOTE: if method receiver is used as a return value, the method call
+  //            should ignore return value
   //
   // - inline eligible 'new-instance' instructions, i.e:
-  //     -> force inline methods called on the instance (which may introduce additional
-  //        instance field reads, but only for fields present in the current field
-  //        initialization mapping)
-  //     -> replace instance field reads with appropriate values passed to the constructor
-  //        according to field initialization mapping
-  //     -> remove constructor call
+  //     -> force inline methods called on the instance (including the initializer);
+  //        (this may introduce additional instance field reads/writes on the receiver)
+  //     -> replace instance field reads with appropriate values calculated based on
+  //        fields writes
+  //     -> remove the call to superclass initializer
+  //     -> remove all field writes
   //     -> remove 'new-instance' instructions
   //
   // For example:
@@ -117,7 +124,6 @@
         .map(Instruction::asNewInstance)
         .collect(Collectors.toList());
 
-    nextNewInstance:
     for (NewInstance newInstance : newInstances) {
       Value eligibleInstance = newInstance.outValue();
       if (eligibleInstance == null) {
@@ -129,177 +135,281 @@
         continue;
       }
 
-      // No Phi users.
-      if (eligibleInstance.numberOfPhiUsers() > 0) {
+      Map<InvokeMethodWithReceiver, InliningInfo> methodCalls = checkInstanceUsersEligibility(
+          appInfo, method, isProcessedConcurrently, newInstance, eligibleInstance, eligibleClass);
+      if (methodCalls == null) {
         continue;
       }
 
-      Set<Instruction> uniqueUsers = eligibleInstance.uniqueUsers();
+      if (getTotalEstimatedMethodSize(methodCalls) >= totalMethodInstructionLimit) {
+        continue;
+      }
 
-      // Find an initializer invocation.
-      InvokeDirect eligibleInitCall = null;
-      Map<DexField, Integer> mappings = null;
-      for (Instruction user : uniqueUsers) {
-        if (!user.isInvokeDirect()) {
+      // Inline the class instance.
+      forceInlineAllMethodInvocations(inliner, methodCalls);
+      removeSuperClassInitializerAndFieldReads(code, newInstance, eligibleInstance);
+      removeFieldWrites(eligibleInstance, eligibleClass);
+      removeInstruction(newInstance);
+
+      // Restore normality.
+      code.removeAllTrivialPhis();
+      assert code.isConsistentSSA();
+    }
+  }
+
+  private Map<InvokeMethodWithReceiver, InliningInfo> checkInstanceUsersEligibility(
+      AppInfoWithSubtyping appInfo, DexEncodedMethod method,
+      Predicate<DexEncodedMethod> isProcessedConcurrently,
+      NewInstance newInstanceInsn, Value receiver, DexType clazz) {
+
+    // No Phi users.
+    if (receiver.numberOfPhiUsers() > 0) {
+      return null; // Not eligible.
+    }
+
+    Map<InvokeMethodWithReceiver, InliningInfo> methodCalls = new IdentityHashMap<>();
+
+    for (Instruction user : receiver.uniqueUsers()) {
+      // Field read/write.
+      if (user.isInstanceGet() ||
+          (user.isInstancePut() && user.asInstancePut().value() != receiver)) {
+        if (user.asFieldInstruction().getField().clazz == newInstanceInsn.clazz) {
+          // Eligible field read or write. Note: as long as we consider only classes eligible
+          // if they directly extend java.lang.Object we don't need to check if the field
+          // really exists in the class.
           continue;
         }
+        return null; // Not eligible.
+      }
 
-        InvokeDirect candidate = user.asInvokeDirect();
-        DexMethod candidateInit = candidate.getInvokedMethod();
-        if (factory.isConstructor(candidateInit) &&
-            candidate.inValues().lastIndexOf(eligibleInstance) == 0) {
+      // Eligible constructor call.
+      if (user.isInvokeDirect()) {
+        InliningInfo inliningInfo = isEligibleConstructorCall(appInfo, method,
+            user.asInvokeDirect(), receiver, clazz, isProcessedConcurrently);
+        if (inliningInfo != null) {
+          methodCalls.put(user.asInvokeDirect(), inliningInfo);
+          continue;
+        }
+        return null; // Not eligible.
+      }
 
-          if (candidateInit.holder != eligibleClass) {
-            // Inlined constructor call? We won't get field initialization mapping in this
-            // case, but since we only support eligible classes extending java.lang.Object,
-            // it's safe to assume an empty mapping.
-            if (candidateInit.holder == factory.objectType) {
-              mappings = Collections.emptyMap();
-            }
+      // Eligible virtual method call.
+      if (user.isInvokeVirtual() || user.isInvokeInterface()) {
+        InliningInfo inliningInfo = isEligibleMethodCall(
+            appInfo, method, user.asInvokeMethodWithReceiver(),
+            receiver, clazz, isProcessedConcurrently);
+        if (inliningInfo != null) {
+          methodCalls.put(user.asInvokeMethodWithReceiver(), inliningInfo);
+          continue;
+        }
+        return null;  // Not eligible.
+      }
 
-          } else {
-            // Is it a call to an *eligible* constructor?
-            mappings = getConstructorFieldMappings(appInfo, candidateInit, isProcessedConcurrently);
-          }
+      return null;  // Not eligible.
+    }
+    return methodCalls;
+  }
 
-          eligibleInitCall = candidate;
+  // Remove call to superclass initializer, replace field reads with appropriate
+  // values, insert phis when needed.
+  private void removeSuperClassInitializerAndFieldReads(
+      IRCode code, NewInstance newInstance, Value eligibleInstance) {
+    Map<DexField, FieldValueHelper> fieldHelpers = new IdentityHashMap<>();
+    for (Instruction user : eligibleInstance.uniqueUsers()) {
+      // Remove the call to superclass constructor.
+      if (user.isInvokeDirect() &&
+          user.asInvokeDirect().getInvokedMethod() == factory.objectMethods.constructor) {
+        removeInstruction(user);
+        continue;
+      }
+
+      if (user.isInstanceGet()) {
+        // Replace a field read with appropriate value.
+        replaceFieldRead(code, newInstance, user.asInstanceGet(), fieldHelpers);
+        continue;
+      }
+
+      if (user.isInstancePut()) {
+        // Skip in this iteration since these instructions are needed to
+        // properly calculate what value should field reads be replaced with.
+        continue;
+      }
+
+      throw new Unreachable("Unexpected usage left after method inlining: " + user);
+    }
+  }
+
+  private void removeFieldWrites(Value receiver, DexType clazz) {
+    for (Instruction user : receiver.uniqueUsers()) {
+      if (!user.isInstancePut()) {
+        throw new Unreachable("Unexpected usage left after field reads removed: " + user);
+      }
+      if (user.asInstancePut().getField().clazz != clazz) {
+        throw new Unreachable("Unexpected field write left after field reads removed: " + user);
+      }
+      removeInstruction(user);
+    }
+  }
+
+  private int getTotalEstimatedMethodSize(Map<InvokeMethodWithReceiver, InliningInfo> methodCalls) {
+    int totalSize = 0;
+    for (InliningInfo info : methodCalls.values()) {
+      totalSize += info.target.getCode().estimatedSizeForInlining();
+    }
+    return totalSize;
+  }
+
+  private void replaceFieldRead(IRCode code, NewInstance newInstance,
+      InstanceGet fieldRead, Map<DexField, FieldValueHelper> fieldHelpers) {
+
+    Value value = fieldRead.outValue();
+    if (value != null) {
+      FieldValueHelper helper = fieldHelpers.computeIfAbsent(
+          fieldRead.getField(), field -> new FieldValueHelper(field, code, newInstance));
+      Value newValue = helper.getValueForFieldRead(fieldRead.getBlock(), fieldRead);
+      value.replaceUsers(newValue);
+      for (FieldValueHelper fieldValueHelper : fieldHelpers.values()) {
+        fieldValueHelper.replaceValue(value, newValue);
+      }
+      assert value.numberOfAllUsers() == 0;
+    }
+    removeInstruction(fieldRead);
+  }
+
+  // Describes and caches what values are supposed to be used instead of field reads.
+  private static final class FieldValueHelper {
+    final DexField field;
+    final IRCode code;
+    final NewInstance newInstance;
+
+    private Value defaultValue = null;
+    private final Map<BasicBlock, Value> ins = new IdentityHashMap<>();
+    private final Map<BasicBlock, Value> outs = new IdentityHashMap<>();
+
+    private FieldValueHelper(DexField field, IRCode code, NewInstance newInstance) {
+      this.field = field;
+      this.code = code;
+      this.newInstance = newInstance;
+    }
+
+    void replaceValue(Value oldValue, Value newValue) {
+      for (Entry<BasicBlock, Value> entry : ins.entrySet()) {
+        if (entry.getValue() == oldValue) {
+          entry.setValue(newValue);
+        }
+      }
+      for (Entry<BasicBlock, Value> entry : outs.entrySet()) {
+        if (entry.getValue() == oldValue) {
+          entry.setValue(newValue);
+        }
+      }
+    }
+
+    Value getValueForFieldRead(BasicBlock block, Instruction valueUser) {
+      assert valueUser != null;
+      Value value = getValueDefinedInTheBlock(block, valueUser);
+      return value != null ? value : getOrCreateInValue(block);
+    }
+
+    private Value getOrCreateOutValue(BasicBlock block) {
+      Value value = outs.get(block);
+      if (value != null) {
+        return value;
+      }
+
+      value = getValueDefinedInTheBlock(block, null);
+      if (value == null) {
+        // No value defined in the block.
+        value = getOrCreateInValue(block);
+      }
+
+      assert value != null;
+      outs.put(block, value);
+      return value;
+    }
+
+    private Value getOrCreateInValue(BasicBlock block) {
+      Value value = ins.get(block);
+      if (value != null) {
+        return value;
+      }
+
+      List<BasicBlock> predecessors = block.getPredecessors();
+      if (predecessors.size() == 1) {
+        value = getOrCreateOutValue(predecessors.get(0));
+        ins.put(block, value);
+      } else {
+        // Create phi, add it to the block, cache in ins map for future use.
+        Phi phi = new Phi(code.valueNumberGenerator.next(),
+            block, ValueType.fromDexType(field.type), null);
+        ins.put(block, phi);
+
+        List<Value> operands = new ArrayList<>();
+        for (BasicBlock predecessor : block.getPredecessors()) {
+          operands.add(getOrCreateOutValue(predecessor));
+        }
+        // Add phi, but don't remove trivial phis; since we cache the phi
+        // we just created for future use we should delay removing trivial
+        // phis until we are done with replacing fields reads.
+        phi.addOperands(operands, false);
+        value = phi;
+      }
+
+      assert value != null;
+      return value;
+    }
+
+    private Value getValueDefinedInTheBlock(BasicBlock block, Instruction stopAt) {
+      InstructionListIterator iterator = stopAt == null ?
+          block.listIterator(block.getInstructions().size()) : block.listIterator(stopAt);
+
+      Instruction valueProducingInsn = null;
+      while (iterator.hasPrevious()) {
+        Instruction instruction = iterator.previous();
+        assert instruction != null;
+
+        if (instruction == newInstance ||
+            (instruction.isInstancePut() &&
+                instruction.asInstancePut().getField() == field &&
+                instruction.asInstancePut().object() == newInstance.outValue())) {
+          valueProducingInsn = instruction;
           break;
         }
       }
 
-      if (mappings == null) {
-        continue;
+      if (valueProducingInsn == null) {
+        return null;
+      }
+      if (valueProducingInsn.isInstancePut()) {
+        return valueProducingInsn.asInstancePut().value();
       }
 
-      // Check all regular users.
-      Map<InvokeMethodWithReceiver, InliningInfo> methodCalls = new IdentityHashMap<>();
-
-      for (Instruction user : uniqueUsers) {
-        if (user == eligibleInitCall) {
-          continue /* next user */;
-        }
-
-        if (user.isInstanceGet()) {
-          InstanceGet instanceGet = user.asInstanceGet();
-          if (mappings.containsKey(instanceGet.getField())) {
-            continue /* next user */;
-          }
-
-          // Not replaceable field read.
-          continue nextNewInstance;
-        }
-
-        if (user.isInvokeVirtual() || user.isInvokeInterface()) {
-          InvokeMethodWithReceiver invoke = user.asInvokeMethodWithReceiver();
-          if (invoke.inValues().lastIndexOf(eligibleInstance) > 0) {
-            continue nextNewInstance; // Instance must only be passes as a receiver.
-          }
-
-          DexEncodedMethod singleTarget =
-              findSingleTarget(appInfo, invoke, eligibleClass);
-          if (singleTarget == null) {
-            continue nextNewInstance;
-          }
-          if (isProcessedConcurrently.test(singleTarget)) {
-            continue nextNewInstance;
-          }
-          if (method == singleTarget) {
-            continue nextNewInstance; // Don't inline itself.
-          }
-
-          if (!singleTarget.getOptimizationInfo()
-              .isReceiverOnlyUsedForReadingFields(mappings.keySet())) {
-            continue nextNewInstance; // Target must be trivial.
-          }
-
-          if (!singleTarget.isInliningCandidate(method, Reason.SIMPLE, appInfo)) {
-            // We won't be able to inline it here.
-
-            // Note that there may be some false negatives here since the method may
-            // reference private fields of its class which are supposed to be replaced
-            // with arguments after inlining. We should try and improve it later.
-
-            // Using -allowaccessmodification mitigates this.
-            continue nextNewInstance;
-          }
-
-          methodCalls.put(invoke, new InliningInfo(singleTarget, eligibleClass));
-          continue /* next user */;
-        }
-
-        continue nextNewInstance; // Unsupported user.
+      assert newInstance == valueProducingInsn;
+      if (defaultValue == null) {
+        // If we met newInstance it means that default value is supposed to be used.
+        defaultValue = code.createValue(ValueType.fromDexType(field.type));
+        ConstNumber defaultValueInsn = new ConstNumber(defaultValue, 0);
+        defaultValueInsn.setPosition(newInstance.getPosition());
+        LinkedList<Instruction> instructions = block.getInstructions();
+        instructions.add(instructions.indexOf(newInstance) + 1, defaultValueInsn);
+        defaultValueInsn.setBlock(block);
       }
-
-      // Force-inline of method invocation if any.
-      inlineAllCalls(inliner, methodCalls);
-      assert assertOnlyConstructorAndFieldReads(eligibleInstance, eligibleInitCall, mappings);
-
-      // Replace all field reads with arguments passed to the constructor.
-      patchFieldReads(eligibleInstance, eligibleInitCall, mappings);
-      assert assertOnlyConstructor(eligibleInstance, eligibleInitCall);
-
-      // Remove constructor call and new-instance instructions.
-      removeInstruction(eligibleInitCall);
-      removeInstruction(newInstance);
-      code.removeAllTrivialPhis();
+      return defaultValue;
     }
   }
 
-  private void inlineAllCalls(
+  private void forceInlineAllMethodInvocations(
       InlinerAction inliner, Map<InvokeMethodWithReceiver, InliningInfo> methodCalls) {
     if (!methodCalls.isEmpty()) {
       inliner.inline(methodCalls);
     }
   }
 
-  private void patchFieldReads(
-      Value instance, InvokeDirect invokeMethod, Map<DexField, Integer> mappings) {
-    for (Instruction user : instance.uniqueUsers()) {
-      if (!user.isInstanceGet()) {
-        continue;
-      }
-      InstanceGet fieldRead = user.asInstanceGet();
-
-      // Replace the field read with
-      assert mappings.containsKey(fieldRead.getField());
-      Value arg = invokeMethod.inValues().get(1 + mappings.get(fieldRead.getField()));
-      assert arg != null;
-      Value value = fieldRead.outValue();
-      if (value != null) {
-        value.replaceUsers(arg);
-        assert value.numberOfAllUsers() == 0;
-      }
-
-      // Remove instruction.
-      removeInstruction(fieldRead);
-    }
-  }
-
   private void removeInstruction(Instruction instruction) {
     instruction.inValues().forEach(v -> v.removeUser(instruction));
     instruction.getBlock().removeInstruction(instruction);
   }
 
-  private boolean assertOnlyConstructorAndFieldReads(
-      Value instance, InvokeDirect invokeMethod, Map<DexField, Integer> mappings) {
-    for (Instruction user : instance.uniqueUsers()) {
-      if (user != invokeMethod &&
-          !(user.isInstanceGet() && mappings.containsKey(user.asFieldInstruction().getField()))) {
-        throw new Unreachable("Not all calls are inlined!");
-      }
-    }
-    return true;
-  }
-
-  private boolean assertOnlyConstructor(Value instance, InvokeDirect invokeMethod) {
-    for (Instruction user : instance.uniqueUsers()) {
-      if (user != invokeMethod) {
-        throw new Unreachable("Not all field reads are substituted!");
-      }
-    }
-    return true;
-  }
-
   private DexEncodedMethod findSingleTarget(
       AppInfo appInfo, InvokeMethodWithReceiver invoke, DexType instanceType) {
 
@@ -322,24 +432,94 @@
     return null;
   }
 
-  private Map<DexField, Integer> getConstructorFieldMappings(
-      AppInfo appInfo, DexMethod init, Predicate<DexEncodedMethod> isProcessedConcurrently) {
-    assert isClassEligible(appInfo, init.holder);
+  private InliningInfo isEligibleConstructorCall(
+      AppInfoWithSubtyping appInfo,
+      DexEncodedMethod method,
+      InvokeDirect initInvoke,
+      Value receiver,
+      DexType inlinedClass,
+      Predicate<DexEncodedMethod> isProcessedConcurrently) {
+
+    // Must be a constructor of the exact same class.
+    DexMethod init = initInvoke.getInvokedMethod();
+    if (!factory.isConstructor(init)) {
+      return null;
+    }
+    // Must be a constructor called on the receiver.
+    if (initInvoke.inValues().lastIndexOf(receiver) != 0) {
+      return null;
+    }
+
+    assert init.holder == inlinedClass
+        : "Inlined constructor? [invoke: " + initInvoke +
+        ", expected class: " + inlinedClass + "]";
 
     DexEncodedMethod definition = appInfo.definitionFor(init);
-    if (definition == null) {
-      return NO_MAPPING;
+    if (definition == null || isProcessedConcurrently.test(definition)) {
+      return null;
     }
 
-    if (isProcessedConcurrently.test(definition)) {
-      return NO_MAPPING;
+    if (!definition.isInliningCandidate(method, Reason.SIMPLE, appInfo)) {
+      // We won't be able to inline it here.
+
+      // Note that there may be some false negatives here since the method may
+      // reference private fields of its class which are supposed to be replaced
+      // with arguments after inlining. We should try and improve it later.
+
+      // Using -allowaccessmodification mitigates this.
+      return null;
     }
 
-    if (definition.accessFlags.isAbstract() || definition.accessFlags.isNative()) {
-      return NO_MAPPING;
+    return definition.getOptimizationInfo().getClassInlinerEligibility() != null
+        ? new InliningInfo(definition, inlinedClass) : null;
+  }
+
+  private InliningInfo isEligibleMethodCall(
+      AppInfoWithSubtyping appInfo,
+      DexEncodedMethod method,
+      InvokeMethodWithReceiver invoke,
+      Value receiver,
+      DexType inlinedClass,
+      Predicate<DexEncodedMethod> isProcessedConcurrently) {
+
+    if (invoke.inValues().lastIndexOf(receiver) > 0) {
+      return null; // Instance passed as an argument.
     }
 
-    return definition.getOptimizationInfo().onlyInitializesFieldsWithNoOtherSideEffects();
+    DexEncodedMethod singleTarget =
+        findSingleTarget(appInfo, invoke, inlinedClass);
+    if (singleTarget == null || isProcessedConcurrently.test(singleTarget)) {
+      return null;
+    }
+    if (method == singleTarget) {
+      return null; // Don't inline itself.
+    }
+
+    ClassInlinerEligibility eligibility =
+        singleTarget.getOptimizationInfo().getClassInlinerEligibility();
+    if (eligibility == null) {
+      return null;
+    }
+
+    // If the method returns receiver and the return value is actually
+    // used in the code the method is not eligible.
+    if (eligibility.returnsReceiver &&
+        invoke.outValue() != null && invoke.outValue().numberOfAllUsers() > 0) {
+      return null;
+    }
+
+    if (!singleTarget.isInliningCandidate(method, Reason.SIMPLE, appInfo)) {
+      // We won't be able to inline it here.
+
+      // Note that there may be some false negatives here since the method may
+      // reference private fields of its class which are supposed to be replaced
+      // with arguments after inlining. We should try and improve it later.
+
+      // Using -allowaccessmodification mitigates this.
+      return null;
+    }
+
+    return new InliningInfo(singleTarget, inlinedClass);
   }
 
   private boolean isClassEligible(AppInfo appInfo, DexType clazz) {
@@ -354,7 +534,7 @@
   }
 
   // Class is eligible for this optimization. Eligibility implementation:
-  //   - not an abstract or interface
+  //   - is not an abstract class or interface
   //   - directly extends java.lang.Object
   //   - does not declare finalizer
   //   - does not trigger any static initializers
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 436c94f..5f0ec45 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -101,6 +101,7 @@
   public boolean enableInlining =
       !Version.isDev() || System.getProperty("com.android.tools.r8.disableinlining") == null;
   public boolean enableClassInlining = true;
+  public int classInliningInstructionLimit = 50;
   public int inliningInstructionLimit = 5;
   public boolean enableSwitchMapRemoval = true;
   public final OutlineOptions outline = new OutlineOptions();
diff --git a/src/test/java/com/android/tools/r8/D8RunExamplesAndroidOTest.java b/src/test/java/com/android/tools/r8/D8RunExamplesAndroidOTest.java
index ede7e53..e01373c 100644
--- a/src/test/java/com/android/tools/r8/D8RunExamplesAndroidOTest.java
+++ b/src/test/java/com/android/tools/r8/D8RunExamplesAndroidOTest.java
@@ -15,6 +15,7 @@
 import org.hamcrest.core.IsInstanceOf;
 import org.hamcrest.core.StringContains;
 import org.junit.Assert;
+import org.junit.Assume;
 import org.junit.Test;
 import org.junit.internal.matchers.ThrowableMessageMatcher;
 
@@ -156,16 +157,20 @@
     // TODO check compilation warnings are correctly reported
 
     // Missing interface B is causing the wrong code to be executed.
-    if (ToolHelper.artSupported()) {
-      thrown.expect(AssertionError.class);
-      execute(
-          "testMissingInterfaceDesugared2AndroidK",
-          "desugaringwithmissingclasstest2.Main",
-          new Path[] {
-              lib1.getInputJar(), lib2.getInputJar(), lib3.getInputJar(), test.getInputJar()
-          },
-          new Path[] {lib1Dex, lib2Dex, lib3Dex, testDex});
+    if (!ToolHelper.artSupported() && !ToolHelper.compareAgaintsGoldenFiles()) {
+      return;
     }
+    if (ToolHelper.artSupported() && !ToolHelper.compareAgaintsGoldenFiles()) {
+      thrown.expect(AssertionError.class);
+    }
+    execute(
+        "testMissingInterfaceDesugared2AndroidK",
+        "desugaringwithmissingclasstest2.Main",
+        new Path[] {
+            lib1.getInputJar(), lib2.getInputJar(), lib3.getInputJar(), test.getInputJar()
+        },
+        new Path[] {lib1Dex, lib2Dex, lib3Dex, testDex});
+
   }
 
   @Test
@@ -256,17 +261,20 @@
     Path testDex = test.build();
     // TODO check compilation warnings are correctly reported
 
+    Assume.assumeTrue(ToolHelper.artSupported() || ToolHelper.compareAgaintsGoldenFiles());
+
     // Missing interface B is causing the wrong method to be executed.
-    if (ToolHelper.artSupported()) {
+    if (ToolHelper.artSupported() && !ToolHelper.compareAgaintsGoldenFiles()) {
       thrown.expect(AssertionError.class);
-      execute(
-          "testCallToMissingSuperInterfaceDesugaredAndroidK",
-          "desugaringwithmissingclasstest3.Main",
-          new Path[] {
-              lib1.getInputJar(), lib2.getInputJar(), lib3.getInputJar(), test.getInputJar()
-          },
-          new Path[] {lib1Dex, lib2Dex, lib3Dex, testDex});
     }
+    execute(
+        "testCallToMissingSuperInterfaceDesugaredAndroidK",
+        "desugaringwithmissingclasstest3.Main",
+        new Path[] {
+            lib1.getInputJar(), lib2.getInputJar(), lib3.getInputJar(), test.getInputJar()
+        },
+        new Path[] {lib1Dex, lib2Dex, lib3Dex, testDex});
+
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java b/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
index ca6feed..2032866 100644
--- a/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
+++ b/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
@@ -12,6 +12,7 @@
 import com.android.tools.r8.ToolHelper.DexVm;
 import com.android.tools.r8.ToolHelper.DexVm.Kind;
 import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.dex.Marker.Tool;
 import com.android.tools.r8.errors.CompilationError;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.shaking.ProguardRuleParserException;
@@ -22,6 +23,7 @@
 import com.android.tools.r8.utils.FileUtils;
 import com.android.tools.r8.utils.InternalOptions.LineNumberOptimization;
 import com.android.tools.r8.utils.ListUtils;
+import com.android.tools.r8.utils.TestDescriptionWatcher;
 import com.google.common.base.Charsets;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableListMultimap;
@@ -1010,8 +1012,7 @@
       // Test depends on exception produced for missing method or similar cases, but
       // after class inlining removes class instantiations and references the exception
       // is not produced.
-      "042-new-instance",
-      "075-verification-error"
+      "435-new-instance"
   );
 
   private static List<String> hasMissingClasses = ImmutableList.of(
@@ -1363,6 +1364,9 @@
   @Rule
   public TemporaryFolder temp = ToolHelper.getTemporaryFolderForTest();
 
+  @Rule
+  public TestDescriptionWatcher watcher = new TestDescriptionWatcher();
+
   public R8RunArtTestsTest(String name, DexTool toolchain) {
     this.name = name;
     this.toolchain = toolchain;
@@ -1554,6 +1558,8 @@
                 if (disableClassInlining) {
                   options.enableClassInlining = false;
                 }
+                // Make sure we don't depend on this settings.
+                options.classInliningInstructionLimit = 10000;
                 options.lineNumberOptimization = LineNumberOptimization.OFF;
                 // Some tests actually rely on missing classes for what they test.
                 options.ignoreMissingClasses = hasMissingClasses;
@@ -1768,7 +1774,7 @@
         specification.disableInlining, specification.disableClassInlining,
         specification.hasMissingClasses);
 
-    if (!ToolHelper.artSupported()) {
+    if (!ToolHelper.artSupported() && !ToolHelper.dealsWithGoldenFiles()) {
       return;
     }
 
@@ -1789,9 +1795,11 @@
 
     boolean compileOnly = System.getProperty("jctf_compile_only", "0").equals("1");
     if (compileOnly || specification.skipArt) {
-      // verify dex code instead of running it
-      Path oatFile = temp.getRoot().toPath().resolve("all.oat");
-      ToolHelper.runDex2Oat(processedFile.toPath(), oatFile);
+      if (ToolHelper.isDex2OatSupported()) {
+        // verify dex code instead of running it
+        Path oatFile = temp.getRoot().toPath().resolve("all.oat");
+        ToolHelper.runDex2Oat(processedFile.toPath(), oatFile);
+      }
       return;
     }
 
@@ -1963,7 +1971,7 @@
           specification.hasMissingClasses);
     }
 
-    if (!specification.skipArt && ToolHelper.artSupported()) {
+    if (!specification.skipArt && (ToolHelper.artSupported() || ToolHelper.dealsWithGoldenFiles())) {
       File originalFile;
       File processedFile;
 
diff --git a/src/test/java/com/android/tools/r8/R8RunExamplesCommon.java b/src/test/java/com/android/tools/r8/R8RunExamplesCommon.java
index 62dd4af..fe5ae72 100644
--- a/src/test/java/com/android/tools/r8/R8RunExamplesCommon.java
+++ b/src/test/java/com/android/tools/r8/R8RunExamplesCommon.java
@@ -14,6 +14,7 @@
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.utils.ExceptionUtils;
 import com.android.tools.r8.utils.InternalOptions.LineNumberOptimization;
+import com.android.tools.r8.utils.TestDescriptionWatcher;
 import java.io.IOException;
 import java.nio.file.NoSuchFileException;
 import java.nio.file.Path;
@@ -21,6 +22,7 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ExecutionException;
+import org.junit.Assume;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
@@ -69,6 +71,9 @@
   @Rule
   public TemporaryFolder temp = ToolHelper.getTemporaryFolderForTest();
 
+  @Rule
+  public TestDescriptionWatcher watcher = new TestDescriptionWatcher();
+
   private final Input input;
   private final CompilerUnderTest compiler;
   private final CompilationMode mode;
@@ -183,9 +188,8 @@
 
   @Test
   public void outputIsIdentical() throws IOException, InterruptedException, ExecutionException {
-    if (!ToolHelper.artSupported()) {
-      return;
-    }
+    Assume.assumeTrue(ToolHelper.artSupported() || ToolHelper.compareAgaintsGoldenFiles());
+
 
     DexVm vm = ToolHelper.getDexVm();
 
diff --git a/src/test/java/com/android/tools/r8/R8RunSmaliTestsTest.java b/src/test/java/com/android/tools/r8/R8RunSmaliTestsTest.java
index fc373d2..0f3cadc 100644
--- a/src/test/java/com/android/tools/r8/R8RunSmaliTestsTest.java
+++ b/src/test/java/com/android/tools/r8/R8RunSmaliTestsTest.java
@@ -8,6 +8,7 @@
 import com.android.tools.r8.ToolHelper.DexVm;
 import com.android.tools.r8.ToolHelper.DexVm.Version;
 import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.TestDescriptionWatcher;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import java.nio.file.Path;
@@ -91,6 +92,9 @@
   @Rule
   public TemporaryFolder temp = ToolHelper.getTemporaryFolderForTest();
 
+  @Rule
+  public TestDescriptionWatcher watcher = new TestDescriptionWatcher();
+
   @Parameters(name = "{0}")
   public static Collection<String[]> data() {
     return Arrays.asList(new String[][]{
diff --git a/src/test/java/com/android/tools/r8/RunExamplesAndroidNTest.java b/src/test/java/com/android/tools/r8/RunExamplesAndroidNTest.java
index bb8c686..83df845 100644
--- a/src/test/java/com/android/tools/r8/RunExamplesAndroidNTest.java
+++ b/src/test/java/com/android/tools/r8/RunExamplesAndroidNTest.java
@@ -14,6 +14,7 @@
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.OffOrAuto;
+import com.android.tools.r8.utils.TestDescriptionWatcher;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import java.nio.file.Path;
@@ -73,7 +74,7 @@
 
       build(inputFile, out);
 
-      if (!ToolHelper.artSupported()) {
+      if (!ToolHelper.artSupported() && !ToolHelper.dealsWithGoldenFiles()) {
         return;
       }
 
@@ -118,6 +119,8 @@
 
   @Rule public ExpectedException thrown = ExpectedException.none();
 
+  @Rule public TestDescriptionWatcher watcher = new TestDescriptionWatcher();
+
   @Test
   public void staticInterfaceMethods() throws Throwable {
     test("staticinterfacemethods", "interfacemethods", "StaticInterfaceMethods")
diff --git a/src/test/java/com/android/tools/r8/RunExamplesAndroidOTest.java b/src/test/java/com/android/tools/r8/RunExamplesAndroidOTest.java
index 9fdbf0a..2c6a72a 100644
--- a/src/test/java/com/android/tools/r8/RunExamplesAndroidOTest.java
+++ b/src/test/java/com/android/tools/r8/RunExamplesAndroidOTest.java
@@ -21,6 +21,7 @@
 import com.android.tools.r8.utils.DexInspector.InvokeInstructionSubject;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.OffOrAuto;
+import com.android.tools.r8.utils.TestDescriptionWatcher;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.io.ByteStreams;
@@ -47,6 +48,7 @@
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 import org.junit.rules.TemporaryFolder;
+import org.junit.rules.TestWatcher;
 
 public abstract class RunExamplesAndroidOTest
       <B extends BaseCommand.Builder<? extends BaseCommand, B>> {
@@ -148,7 +150,7 @@
 
       build(inputFile, out);
 
-      if (!ToolHelper.artSupported()) {
+      if (!ToolHelper.artSupported() && !ToolHelper.dealsWithGoldenFiles()) {
         return;
       }
 
@@ -270,6 +272,9 @@
   @Rule
   public ExpectedException thrown = ExpectedException.none();
 
+  @Rule
+  public TestDescriptionWatcher watcher = new TestDescriptionWatcher();
+
   boolean failsOn(Map<ToolHelper.DexVm.Version, List<String>> failsOn, String name) {
     Version vmVersion = ToolHelper.getDexVm().getVersion();
     return failsOn.containsKey(vmVersion)
@@ -553,14 +558,14 @@
       throws IOException {
 
     boolean expectedToFail = expectedToFail(testName);
-    if (expectedToFail) {
+    if (expectedToFail && !ToolHelper.compareAgaintsGoldenFiles()) {
       thrown.expect(Throwable.class);
     }
     String output = ToolHelper.runArtNoVerificationErrors(
         Arrays.stream(dexes).map(path -> path.toString()).collect(Collectors.toList()),
         qualifiedMainClass,
         null);
-    if (!expectedToFail && !skipRunningOnJvm(testName)) {
+    if (!expectedToFail && !skipRunningOnJvm(testName) && !ToolHelper.compareAgaintsGoldenFiles()) {
       ToolHelper.ProcessResult javaResult =
           ToolHelper.runJava(ImmutableList.copyOf(jars), qualifiedMainClass);
       assertEquals("JVM run failed", javaResult.exitCode, 0);
diff --git a/src/test/java/com/android/tools/r8/RunExamplesAndroidPTest.java b/src/test/java/com/android/tools/r8/RunExamplesAndroidPTest.java
index bc898bd..182fe80 100644
--- a/src/test/java/com/android/tools/r8/RunExamplesAndroidPTest.java
+++ b/src/test/java/com/android/tools/r8/RunExamplesAndroidPTest.java
@@ -19,6 +19,7 @@
 import com.android.tools.r8.utils.DexInspector.InstructionSubject;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.OffOrAuto;
+import com.android.tools.r8.utils.TestDescriptionWatcher;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.io.ByteStreams;
@@ -143,7 +144,7 @@
 
       build(inputFile, out);
 
-      if (!ToolHelper.artSupported()) {
+      if (!ToolHelper.artSupported() && !ToolHelper.dealsWithGoldenFiles()) {
         return;
       }
 
@@ -193,6 +194,9 @@
   @Rule
   public ExpectedException thrown = ExpectedException.none();
 
+  @Rule
+  public TestDescriptionWatcher watcher = new TestDescriptionWatcher();
+
   boolean failsOn(Map<DexVm.Version, List<String>> failsOn, String name) {
     DexVm.Version vmVersion = ToolHelper.getDexVm().getVersion();
     return failsOn.containsKey(vmVersion)
diff --git a/src/test/java/com/android/tools/r8/RunExamplesJava9Test.java b/src/test/java/com/android/tools/r8/RunExamplesJava9Test.java
index 281b0da..284ed68 100644
--- a/src/test/java/com/android/tools/r8/RunExamplesJava9Test.java
+++ b/src/test/java/com/android/tools/r8/RunExamplesJava9Test.java
@@ -19,6 +19,7 @@
 import com.android.tools.r8.utils.DexInspector.InstructionSubject;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.OffOrAuto;
+import com.android.tools.r8.utils.TestDescriptionWatcher;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.io.ByteStreams;
@@ -143,7 +144,7 @@
 
       build(inputFile, out);
 
-      if (!ToolHelper.artSupported()) {
+      if (!ToolHelper.artSupported() && !ToolHelper.dealsWithGoldenFiles()) {
         return;
       }
 
@@ -224,6 +225,9 @@
   @Rule
   public ExpectedException thrown = ExpectedException.none();
 
+  @Rule
+  public TestDescriptionWatcher watcher = new TestDescriptionWatcher();
+
   boolean failsOn(Map<DexVm.Version, List<String>> failsOn, String name) {
     DexVm.Version vmVersion = ToolHelper.getDexVm().getVersion();
     return failsOn.containsKey(vmVersion)
diff --git a/src/test/java/com/android/tools/r8/TestBase.java b/src/test/java/com/android/tools/r8/TestBase.java
index 331af0a..add86c2 100644
--- a/src/test/java/com/android/tools/r8/TestBase.java
+++ b/src/test/java/com/android/tools/r8/TestBase.java
@@ -26,6 +26,7 @@
 import com.android.tools.r8.utils.FileUtils;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.PreloadedClassFileProvider;
+import com.android.tools.r8.utils.TestDescriptionWatcher;
 import com.android.tools.r8.utils.ZipUtils;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
@@ -59,6 +60,9 @@
   @Rule
   public TemporaryFolder temp = ToolHelper.getTemporaryFolderForTest();
 
+  @Rule
+  public TestDescriptionWatcher watcher = new TestDescriptionWatcher();
+
   /**
    * Check if tests should also run Proguard when applicable.
    */
diff --git a/src/test/java/com/android/tools/r8/ToolHelper.java b/src/test/java/com/android/tools/r8/ToolHelper.java
index 68d87c1..000076e 100644
--- a/src/test/java/com/android/tools/r8/ToolHelper.java
+++ b/src/test/java/com/android/tools/r8/ToolHelper.java
@@ -23,18 +23,23 @@
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.AndroidAppConsumers;
 import com.android.tools.r8.utils.DefaultDiagnosticsHandler;
+import com.android.tools.r8.utils.FileUtils;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.ListUtils;
 import com.android.tools.r8.utils.Reporter;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.Timing;
+import com.android.tools.r8.utils.ZipUtils;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Lists;
 import com.google.common.io.ByteStreams;
 import com.google.common.io.CharStreams;
+import com.google.gson.Gson;
 import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
@@ -702,6 +707,10 @@
     return true;
   }
 
+  public static boolean isDex2OatSupported() {
+    return !isWindows();
+  }
+
   public static Path getClassPathForTests() {
     return Paths.get(BUILD_DIR, "classes", "test");
   }
@@ -793,12 +802,22 @@
   }
 
   public static R8Command.Builder prepareR8CommandBuilder(AndroidApp app) {
-    return R8Command.builder(app).setProgramConsumer(DexIndexedConsumer.emptyConsumer());
+    return prepareR8CommandBuilder(app, DexIndexedConsumer.emptyConsumer());
+  }
+
+  public static R8Command.Builder prepareR8CommandBuilder(
+      AndroidApp app, ProgramConsumer programConsumer) {
+    return R8Command.builder(app).setProgramConsumer(programConsumer);
   }
 
   public static AndroidApp runR8(AndroidApp app) throws IOException {
+    return runR8WithProgramConsumer(app, DexIndexedConsumer.emptyConsumer());
+  }
+
+  public static AndroidApp runR8WithProgramConsumer(AndroidApp app, ProgramConsumer programConsumer)
+      throws IOException {
     try {
-      return runR8(prepareR8CommandBuilder(app).build());
+      return runR8(prepareR8CommandBuilder(app, programConsumer).build());
     } catch (CompilationFailedException e) {
       throw new RuntimeException(e);
     }
@@ -1011,17 +1030,197 @@
     return runArtRaw(files, mainClass, extras, null);
   }
 
+  // Index used to name directory aimed at storing dex files and process result
+  // for one invokation of runArtRaw() in order to avoid conflicts in case of
+  // multiple calls within the same test.
+  private static int testOutputPathIndex = 0;
+
   public static ProcessResult runArtRaw(List<String> files, String mainClass,
       Consumer<ArtCommandBuilder> extras, DexVm version)
       throws IOException {
-    ArtCommandBuilder builder =
-        version != null ? new ArtCommandBuilder(version) : new ArtCommandBuilder();
-    files.forEach(builder::appendClasspath);
-    builder.setMainClass(mainClass);
-    if (extras != null) {
-      extras.accept(builder);
+
+      ArtCommandBuilder builder =
+          version != null ? new ArtCommandBuilder(version) : new ArtCommandBuilder();
+      files.forEach(builder::appendClasspath);
+      builder.setMainClass(mainClass);
+      if (extras != null) {
+        extras.accept(builder);
+      }
+
+      ProcessResult processResult = null;
+
+      // Whenever we start a new test method we reset the index count.
+      String reset_output_index = System.getProperty("reset_output_index");
+      if (reset_output_index != null) {
+        System.clearProperty("reset_output_index");
+        testOutputPathIndex = 0;
+      } else {
+        assert testOutputPathIndex >= 0;
+        testOutputPathIndex++;
+      }
+
+      String goldenFilesDirInProp = System.getProperty("use_golden_files_in");
+      if (goldenFilesDirInProp != null) {
+        File goldenFileDir = new File(goldenFilesDirInProp);
+        assert goldenFileDir.isDirectory();
+        processResult = compareAgainstGoldenFiles(
+            files.stream().map(f -> new File(f)).collect(Collectors.toList()), goldenFileDir);
+        if (processResult.exitCode == 0) {
+          processResult = readProcessResult(goldenFileDir);
+        }
+      } else {
+        processResult = runArtProcessRaw(builder);
+      }
+
+      String goldenFilesDirToProp = System.getProperty("generate_golden_files_to");
+      if (goldenFilesDirToProp != null) {
+        File goldenFileDir = new File(goldenFilesDirToProp);
+        assert goldenFileDir.isDirectory();
+        storeAsGoldenFiles(files.stream().map(f -> new File(f)).collect(Collectors.toList()),
+            goldenFileDir);
+        storeProcessResult(processResult, goldenFileDir);
+      }
+
+      return processResult;
+  }
+
+  private static Path findNonConflictingDestinationFilePath(Path testOutputPath) {
+    int index = 0;
+    Path destFilePath;
+    do {
+      destFilePath = Paths.get(testOutputPath.toString(),
+          "classes-" + String.format("%03d", index) + FileUtils.DEX_EXTENSION);
+      index++;
+    } while (destFilePath.toFile().exists());
+
+    return destFilePath;
+  }
+
+  private static Path getTestOutputPath(File destDir) throws IOException {
+    assert destDir.exists();
+    assert destDir.isDirectory();
+
+    String testClassName = System.getProperty("test_class_name");
+    String testName = System.getProperty("test_name");
+    String headSha1 = System.getProperty("test_git_HEAD_sha1");
+
+    assert testClassName != null;
+    assert testName != null;
+    assert headSha1 != null;
+
+    return Files.createDirectories(
+         Paths.get(destDir.getAbsolutePath(), headSha1, testClassName, testName + "-" + String
+             .format("%03d", testOutputPathIndex)));
+  }
+
+  private static List<File> unzipDexFilesArchive(File zipFile) throws IOException {
+    File tmpDir = Files.createTempDirectory("r8-test-").toFile();
+    tmpDir.deleteOnExit();
+    return ZipUtils.unzip(zipFile.getAbsolutePath(), tmpDir);
+  }
+
+  private static void storeAsGoldenFiles(List<File> files, File destDir) throws IOException {
+    Path testOutputPath = getTestOutputPath(destDir);
+
+    for (File f : files) {
+      Path filePath = f.toPath();
+      // TODO(jmhenaff): Check it's been produced by D8/R8?
+      List<File> testFiles = Collections.singletonList(f);
+      if (FileUtils.isArchive(filePath)) {
+        testFiles = unzipDexFilesArchive(f);
+      }
+      for (File testFile : testFiles) {
+        Path testFilePath = testFile.toPath();
+        if (FileUtils.isDexFile(testFilePath)) {
+          Path destFile = findNonConflictingDestinationFilePath(testOutputPath);
+          FileUtils.writeToFile(destFile, null, Files.readAllBytes(testFilePath));
+        }
+      }
     }
-    return runArtProcessRaw(builder);
+  }
+
+  @SuppressWarnings("unchecked")
+  private static void storeProcessResult(ProcessResult processResult, File dest)
+      throws IOException {
+    Gson gson = new Gson();
+    Path testOutputPath = getTestOutputPath(dest);
+    try (FileWriter fw = new FileWriter(new File(testOutputPath.toFile(), "processResult.json"))) {
+      gson.toJson(processResult, ProcessResult.class, fw);
+    }
+  }
+
+  private static ProcessResult readProcessResult(File dest) throws IOException {
+    File processResultFile = new File(getTestOutputPath(dest).toFile(), "processResult.json");
+    Gson gson = new Gson();
+    try (FileReader fr = new FileReader(processResultFile)) {
+      return gson.fromJson(fr, ProcessResult.class);
+    }
+  }
+
+  private static ProcessResult compareAgainstGoldenFiles(List<File> files, File destDir)
+      throws IOException {
+    Path testOutputPath = getTestOutputPath(destDir);
+
+    int index = 0;
+    String stdErr = "";
+    boolean passed = true;
+    for (File f : files) {
+      Path filePath = f.toPath();
+
+      List<File> testFiles = Collections.singletonList(f);
+      if (FileUtils.isArchive(filePath)) {
+        testFiles = unzipDexFilesArchive(f);
+      }
+
+      for (File testFile : testFiles) {
+        Path testFilePath = testFile.toPath();
+        // TODO(jmhenaff): Check it's been produced by D8/R8?
+        if (FileUtils.isDexFile(testFilePath)) {
+          File goldenFile = Paths.get(testOutputPath.toString(),
+              "classes-" + String.format("%03d", index) + FileUtils.DEX_EXTENSION).toFile();
+          if (!goldenFile.exists()) {
+            String fileDesc = "'" + testFile.getAbsolutePath() + "'";
+            if (FileUtils.isZipFile(filePath)) {
+              fileDesc += " (extracted from '" + f.getAbsolutePath() + "')";
+            }
+            stdErr += "Cannot find golden file '" + goldenFile.getAbsolutePath()
+                + "' to compare against test file " + fileDesc + "\n";
+            passed = false;
+          } else if (!com.google.common.io.Files.equal(testFile, goldenFile)) {
+            String fileDesc = "'" + testFile.getAbsolutePath() + "'";
+            if (FileUtils.isZipFile(filePath)) {
+              fileDesc += " (extracted from '" + f.getAbsolutePath() + "')";
+            }
+            stdErr +=
+                "File " + fileDesc + " differs from golden file '" + goldenFile.getAbsolutePath()
+                    + "'\n";
+            passed = false;
+          }
+          index++;
+        }
+      }
+    }
+    // Ensure we processed as many files as there are golden files
+    File goldenFile = Paths.get(testOutputPath.toString(),
+        "classes-" + String.format("%03d", index) + FileUtils.DEX_EXTENSION).toFile();
+    if (goldenFile.exists()) {
+      stdErr += "Less dex files have been produced: there is at least one more golden file ('"
+          + goldenFile.getAbsolutePath() + "'\n";
+      passed = false;
+    }
+    return new ProcessResult(passed ? 0 : -1, "", stdErr);
+  }
+
+  public static boolean dealsWithGoldenFiles() {
+    return compareAgaintsGoldenFiles() || generateGoldenFiles();
+  }
+
+  public static boolean compareAgaintsGoldenFiles() {
+    return System.getProperty("use_golden_files_in") != null;
+  }
+
+  public static boolean generateGoldenFiles() {
+    return System.getProperty("generate_golden_files_to") != null;
   }
 
   public static ProcessResult runArtNoVerificationErrorsRaw(String file, String mainClass)
@@ -1076,7 +1275,7 @@
   }
 
   private static ProcessResult runArtProcessRaw(ArtCommandBuilder builder) throws IOException {
-    Assume.assumeTrue(ToolHelper.artSupported());
+    Assume.assumeTrue(artSupported() || dealsWithGoldenFiles());
     ProcessResult result;
     if (builder.isForDevice()) {
       try {
@@ -1151,7 +1350,7 @@
   }
 
   public static void runDex2Oat(Path file, Path outFile, DexVm vm) throws IOException {
-    Assume.assumeTrue(ToolHelper.artSupported());
+    Assume.assumeTrue(ToolHelper.isDex2OatSupported());
     // TODO(jmhenaff): find a way to run this on windows (push dex and run on device/emulator?)
     Assume.assumeTrue(!ToolHelper.isWindows());
     assert Files.exists(file);
diff --git a/src/test/java/com/android/tools/r8/VmTestRunner.java b/src/test/java/com/android/tools/r8/VmTestRunner.java
index 978cbe7..a3e76a4 100644
--- a/src/test/java/com/android/tools/r8/VmTestRunner.java
+++ b/src/test/java/com/android/tools/r8/VmTestRunner.java
@@ -68,7 +68,7 @@
   @Override
   protected boolean isIgnored(FrameworkMethod child) {
     // Do not run VM tests if running VMs is not even supported.
-    if (!ToolHelper.artSupported()) {
+    if (!ToolHelper.artSupported() && !ToolHelper.dealsWithGoldenFiles()) {
       return true;
     }
     if (super.isIgnored(child)) {
diff --git a/src/test/java/com/android/tools/r8/cf/AlwaysNullGetItemTestRunner.java b/src/test/java/com/android/tools/r8/cf/AlwaysNullGetItemTestRunner.java
index a24e95a..7d88649 100644
--- a/src/test/java/com/android/tools/r8/cf/AlwaysNullGetItemTestRunner.java
+++ b/src/test/java/com/android/tools/r8/cf/AlwaysNullGetItemTestRunner.java
@@ -14,6 +14,7 @@
 import com.android.tools.r8.ToolHelper.ProcessResult;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.TestDescriptionWatcher;
 import java.nio.file.Path;
 import org.junit.Rule;
 import org.junit.Test;
@@ -25,6 +26,9 @@
   @Rule
   public TemporaryFolder temp = ToolHelper.getTemporaryFolderForTest();
 
+  @Rule
+  public TestDescriptionWatcher watcher = new TestDescriptionWatcher();
+
   @Test
   public void test() throws Exception {
     ProcessResult runInput =
diff --git a/src/test/java/com/android/tools/r8/cf/IdenticalCatchHandlerTest.java b/src/test/java/com/android/tools/r8/cf/IdenticalCatchHandlerTest.java
new file mode 100644
index 0000000..fd696bc
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/cf/IdenticalCatchHandlerTest.java
@@ -0,0 +1,88 @@
+// 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 static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+
+import com.android.tools.r8.ClassFileConsumer;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.cf.code.CfLabel;
+import com.android.tools.r8.cf.code.CfTryCatch;
+import com.android.tools.r8.errors.Unimplemented;
+import com.android.tools.r8.graph.CfCode;
+import com.android.tools.r8.graph.Code;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexCode;
+import com.android.tools.r8.graph.DexCode.Try;
+import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.DexInspector;
+import com.google.common.collect.Sets;
+import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
+import it.unimi.dsi.fastutil.ints.IntSet;
+import java.nio.file.Paths;
+import java.util.Set;
+import org.junit.Test;
+
+public class IdenticalCatchHandlerTest extends TestBase {
+
+  private static class TestClass {
+    public void foo(Object a, Object b, Object c) {
+      if (a == null) {
+        try {
+          System.out.println(b.toString());
+        } catch (RuntimeException e) {
+        }
+      } else {
+        try {
+          System.out.println(c.toString());
+        } catch (RuntimeException e) {
+        }
+      }
+      System.out.println("Hello");
+    }
+  }
+
+  @Test
+  public void test() throws Exception {
+    byte[] inputBytes = ToolHelper.getClassAsBytes(TestClass.class);
+    AndroidApp inputApp =
+        AndroidApp.builder()
+            .addClassProgramData(inputBytes, Origin.unknown())
+            .addLibraryFiles(Paths.get(ToolHelper.JAVA_8_RUNTIME))
+            .build();
+    assertEquals(2, countCatchHandlers(inputApp));
+    AndroidApp outputDexApp = ToolHelper.runR8(inputApp);
+    assertEquals(1, countCatchHandlers(outputDexApp));
+    AndroidApp outputCfApp =
+        ToolHelper.runR8WithProgramConsumer(inputApp, ClassFileConsumer.emptyConsumer());
+    // TODO(b/80514966): Change to assertEquals when fixed.
+    assertNotEquals(1, countCatchHandlers(outputCfApp));
+  }
+
+  private int countCatchHandlers(AndroidApp inputApp) throws Exception {
+    DexInspector inspector = new DexInspector(inputApp, o -> o.enableCfFrontend = true);
+    DexClass dexClass = inspector.clazz(TestClass.class).getDexClass();
+    Code code = dexClass.virtualMethods()[0].getCode();
+    if (code.isCfCode()) {
+      CfCode cfCode = code.asCfCode();
+      Set<CfLabel> targets = Sets.newIdentityHashSet();
+      for (CfTryCatch tryCatch : cfCode.getTryCatchRanges()) {
+        targets.addAll(tryCatch.targets);
+      }
+      return targets.size();
+    } else if (code.isDexCode()) {
+      DexCode dexCode = code.asDexCode();
+      IntSet targets = new IntOpenHashSet();
+      for (Try aTry : dexCode.tries) {
+        targets.add(aTry.handlerOffset);
+      }
+      return targets.size();
+    } else {
+      throw new Unimplemented(code.getClass().getName());
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/cf/MethodHandleTestRunner.java b/src/test/java/com/android/tools/r8/cf/MethodHandleTestRunner.java
index e43ffd7..6069b4c 100644
--- a/src/test/java/com/android/tools/r8/cf/MethodHandleTestRunner.java
+++ b/src/test/java/com/android/tools/r8/cf/MethodHandleTestRunner.java
@@ -31,6 +31,7 @@
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;
 
+
 @RunWith(Parameterized.class)
 public class MethodHandleTestRunner extends TestBase {
   static final Class<?> CLASS = MethodHandleTest.class;
@@ -143,8 +144,8 @@
     if (runInput.exitCode != runDex.exitCode) {
       System.out.println(runDex.stderr);
     }
-    assertEquals(runInput.stdout, runDex.stdout);
     assertEquals(runInput.exitCode, runDex.exitCode);
+    assertEquals(runInput.stdout, runDex.stdout);
   }
 
   private void build(ProgramConsumer programConsumer) throws Exception {
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 25356ae..d41ee84 100644
--- a/src/test/java/com/android/tools/r8/debug/DebugTestBase.java
+++ b/src/test/java/com/android/tools/r8/debug/DebugTestBase.java
@@ -16,6 +16,7 @@
 import com.android.tools.r8.naming.MemberNaming.Signature;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.TestDescriptionWatcher;
 import com.google.common.collect.ImmutableList;
 import it.unimi.dsi.fastutil.longs.LongArrayList;
 import it.unimi.dsi.fastutil.longs.LongList;
@@ -113,6 +114,9 @@
   @Rule
   public TestName testName = new TestName();
 
+  @Rule
+  public TestDescriptionWatcher watcher = new TestDescriptionWatcher();
+
   protected static final boolean supportsDefaultMethod(DebugTestConfig config) {
     return config.isCfRuntime()
         || ToolHelper.getMinApiLevelForDexVm().getLevel() >= AndroidApiLevel.N.getLevel();
diff --git a/src/test/java/com/android/tools/r8/debuginfo/DebugInfoTestBase.java b/src/test/java/com/android/tools/r8/debuginfo/DebugInfoTestBase.java
index d0ad1df..6f85b18 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/DebugInfoTestBase.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/DebugInfoTestBase.java
@@ -15,6 +15,7 @@
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.AndroidAppConsumers;
+import com.android.tools.r8.utils.TestDescriptionWatcher;
 import com.google.common.collect.ImmutableList;
 import java.io.IOException;
 import java.nio.file.Path;
@@ -31,6 +32,9 @@
   @Rule
   public TemporaryFolder temp = ToolHelper.getTemporaryFolderForTest();
 
+  @Rule
+  public TestDescriptionWatcher watcher = new TestDescriptionWatcher();
+
   static AndroidApp compileWithD8(Class... classes) throws IOException, CompilationFailedException {
     D8Command.Builder builder = D8Command.builder();
     for (Class clazz : classes) {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/R8InliningRegressionTests.java b/src/test/java/com/android/tools/r8/ir/optimize/R8InliningRegressionTests.java
index 6760bdd..cb6df88 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/R8InliningRegressionTests.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/R8InliningRegressionTests.java
@@ -35,7 +35,7 @@
   }
 
   private void buildAndTest(String folder, String mainClass) throws Exception {
-    Assume.assumeTrue(ToolHelper.artSupported());
+    Assume.assumeTrue(ToolHelper.artSupported() || ToolHelper.compareAgaintsGoldenFiles());
 
     Path proguardRules = Paths.get(ToolHelper.EXAMPLES_DIR, folder, "keep-rules.txt");
     Path jarFile =
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java
index e9319d2..d36e6ad 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java
@@ -16,6 +16,11 @@
 import com.android.tools.r8.VmTestRunner;
 import com.android.tools.r8.code.NewInstance;
 import com.android.tools.r8.graph.DexCode;
+import com.android.tools.r8.ir.optimize.classinliner.builders.BuildersTestClass;
+import com.android.tools.r8.ir.optimize.classinliner.builders.ControlFlow;
+import com.android.tools.r8.ir.optimize.classinliner.builders.Pair;
+import com.android.tools.r8.ir.optimize.classinliner.builders.PairBuilder;
+import com.android.tools.r8.ir.optimize.classinliner.builders.Tuple;
 import com.android.tools.r8.ir.optimize.classinliner.trivial.ClassWithFinal;
 import com.android.tools.r8.ir.optimize.classinliner.trivial.CycleReferenceAB;
 import com.android.tools.r8.ir.optimize.classinliner.trivial.CycleReferenceBA;
@@ -75,8 +80,7 @@
         collectNewInstanceTypes(clazz, "testConstructorMapping1"));
 
     assertEquals(
-        Collections.singleton(
-            "com.android.tools.r8.ir.optimize.classinliner.trivial.ReferencedFields"),
+        Collections.emptySet(),
         collectNewInstanceTypes(clazz, "testConstructorMapping2"));
 
     assertEquals(
@@ -120,6 +124,60 @@
     assertFalse(inspector.clazz(CycleReferenceBA.class).isPresent());
   }
 
+  @Test
+  public void testBuilders() throws Exception {
+    byte[][] classes = {
+        ToolHelper.getClassAsBytes(BuildersTestClass.class),
+        ToolHelper.getClassAsBytes(BuildersTestClass.Pos.class),
+        ToolHelper.getClassAsBytes(Tuple.class),
+        ToolHelper.getClassAsBytes(Pair.class),
+        ToolHelper.getClassAsBytes(PairBuilder.class),
+        ToolHelper.getClassAsBytes(ControlFlow.class),
+    };
+    String main = BuildersTestClass.class.getCanonicalName();
+    ProcessResult javaOutput = runOnJava(main, classes);
+    assertEquals(0, javaOutput.exitCode);
+
+    AndroidApp app = runR8(buildAndroidApp(classes), BuildersTestClass.class);
+
+    DexInspector inspector = new DexInspector(app);
+    ClassSubject clazz = inspector.clazz(BuildersTestClass.class);
+
+    assertEquals(
+        Sets.newHashSet(
+            "com.android.tools.r8.ir.optimize.classinliner.builders.Pair",
+            "java.lang.StringBuilder"),
+        collectNewInstanceTypes(clazz, "testSimpleBuilder"));
+
+    // Note that Pair created instances were also inlined in the following method since
+    // we use 'System.out.println(pX.toString())', if we used 'System.out.println(pX)'
+    // as in the above method, the instance of pair would be passed to println() which
+    // would make it not eligible for inlining.
+    assertEquals(
+        Collections.singleton("java.lang.StringBuilder"),
+        collectNewInstanceTypes(clazz, "testSimpleBuilderWithMultipleBuilds"));
+
+    assertFalse(inspector.clazz(PairBuilder.class).isPresent());
+
+    assertEquals(
+        Collections.singleton("java.lang.StringBuilder"),
+        collectNewInstanceTypes(clazz, "testBuilderConstructors"));
+
+    assertFalse(inspector.clazz(Tuple.class).isPresent());
+
+    assertEquals(
+        Collections.singleton("java.lang.StringBuilder"),
+        collectNewInstanceTypes(clazz, "testWithControlFlow"));
+
+    assertFalse(inspector.clazz(ControlFlow.class).isPresent());
+
+    assertEquals(
+        Collections.emptySet(),
+        collectNewInstanceTypes(clazz, "testWithMoreControlFlow"));
+
+    assertFalse(inspector.clazz(BuildersTestClass.Pos.class).isPresent());
+  }
+
   private Set<String> collectNewInstanceTypes(
       ClassSubject clazz, String methodName, String... params) {
     assertNotNull(clazz);
@@ -135,7 +193,11 @@
         + "-dontobfuscate\n"
         + "-allowaccessmodification";
 
-    AndroidApp compiled = compileWithR8(app, config, o -> o.enableClassInlining = true);
+    AndroidApp compiled = compileWithR8(app, config,
+        o -> {
+          o.enableClassInlining = true;
+          o.classInliningInstructionLimit = 10000;
+        });
 
     // Materialize file for execution.
     Path generatedDexFile = temp.getRoot().toPath().resolve("classes.jar");
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/builders/BuildersTestClass.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/builders/BuildersTestClass.java
new file mode 100644
index 0000000..1516e14
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/builders/BuildersTestClass.java
@@ -0,0 +1,95 @@
+// 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.optimize.classinliner.builders;
+
+public class BuildersTestClass {
+  private static int ID = 0;
+
+  private static int nextInt() {
+    return ID++;
+  }
+
+  private static String next() {
+    return Integer.toString(nextInt());
+  }
+
+  public static void main(String[] args) {
+    BuildersTestClass test = new BuildersTestClass();
+    test.testSimpleBuilder();
+    test.testSimpleBuilderWithMultipleBuilds();
+    test.testBuilderConstructors();
+    test.testWithControlFlow();
+    test.testWithMoreControlFlow();
+  }
+
+  private synchronized void testSimpleBuilder() {
+    System.out.println(
+        new PairBuilder<String, String>().setFirst("f-" + next()).build().toString());
+    testSimpleBuilder2();
+    testSimpleBuilder3();
+  }
+
+  private synchronized void testSimpleBuilder2() {
+    System.out.println(
+        new PairBuilder<String, String>().setSecond("s-" + next()).build().toString());
+  }
+
+  private synchronized void testSimpleBuilder3() {
+    System.out.println(new PairBuilder<String, String>()
+        .setFirst("f-" + next()).setSecond("s-" + next()).build().toString());
+  }
+
+  private synchronized void testSimpleBuilderWithMultipleBuilds() {
+    PairBuilder<String, String> builder = new PairBuilder<>();
+    Pair p1 = builder.build();
+    System.out.println(p1.toString());
+    builder.setFirst("f-" + next());
+    Pair p2 = builder.build();
+    System.out.println(p2.toString());
+    builder.setSecond("s-" + next());
+    Pair p3 = builder.build();
+    System.out.println(p3.toString());
+  }
+
+  private synchronized void testBuilderConstructors() {
+    System.out.println(new Tuple().toString());
+    System.out.println(new Tuple(true, (byte) 77, (short) 9977, '#', 42,
+        987654321123456789L, -12.34f, 43210.98765, "s-" + next() + "-s").toString());
+  }
+
+  private synchronized void testWithControlFlow() {
+    ControlFlow flow = new ControlFlow(-1, 2, 7);
+    for (int k = 0; k < 25; k++) {
+      if (k % 3 == 0) {
+        flow.foo(k);
+      } else if (k % 3 == 1) {
+        flow.bar(nextInt(), nextInt(), nextInt(), nextInt());
+      }
+    }
+    System.out.println("flow = " + flow.toString());
+  }
+
+  private synchronized void testWithMoreControlFlow() {
+    String str = "1234567890";
+    Pos pos = new Pos();
+    while (pos.y < str.length()) {
+      pos.x = pos.y;
+      pos.y = pos.x;
+
+      if (str.charAt(pos.x) != '*') {
+        if ('0' <= str.charAt(pos.y) && str.charAt(pos.y) <= '9') {
+          while (pos.y < str.length() && '0' <= str.charAt(pos.y) && str.charAt(pos.y) <= '9') {
+            pos.y++;
+          }
+        }
+      }
+    }
+  }
+
+  public static class Pos {
+    public int x = 0;
+    public int y = 0;
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/builders/ControlFlow.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/builders/ControlFlow.java
new file mode 100644
index 0000000..7b95dc1
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/builders/ControlFlow.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.ir.optimize.classinliner.builders;
+
+public class ControlFlow {
+  int a;
+  int b;
+  int c = 1234;
+  int d;
+  String s = ">";
+
+  ControlFlow(int b, int c, int d) {
+    this.s += this.a++ + ">";
+    this.s += this.b + ">";
+    this.b = b;
+    this.s += this.b + ">";
+    this.s += this.c + ">";
+    this.c += c;
+    this.s += this.c + ">";
+    this.s += (this.d = d) + ">";
+  }
+
+  public void foo(int count) {
+    for (int i = 0; i < count; i++) {
+      switch (i % 4) {
+        case 0:
+          this.s += ++this.a + ">";
+          break;
+        case 1:
+          this.c += this.b;
+          this.s += this.c + ">";
+          break;
+        case 2:
+          this.d += this.d++ + this.c++ + this.b++ + this.a++;
+          this.s += this.d + ">";
+          break;
+      }
+    }
+  }
+
+  public void bar(int a, int b, int c, int d) {
+    this.a += a;
+    this.b += b;
+    this.c += c;
+    this.d += d;
+  }
+
+  @Override
+  public String toString() {
+    return s;
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/builders/Pair.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/builders/Pair.java
new file mode 100644
index 0000000..af45cab
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/builders/Pair.java
@@ -0,0 +1,22 @@
+// 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.optimize.classinliner.builders;
+
+public class Pair<F, S> {
+  public final F first;
+  public final S second;
+
+  public Pair(F first, S second) {
+    this.first = first;
+    this.second = second;
+  }
+
+  @Override
+  public String toString() {
+    return "Pair(" +
+        (first == null ? "<null>" : first) + ", " +
+        (second == null ? "<null>" : second) + ")";
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/builders/PairBuilder.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/builders/PairBuilder.java
new file mode 100644
index 0000000..0c80c53
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/builders/PairBuilder.java
@@ -0,0 +1,29 @@
+// 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.optimize.classinliner.builders;
+
+public class PairBuilder<F, S> {
+  public F first;
+  public S second = null;
+
+  public PairBuilder<F, S> setFirst(F first) {
+    System.out.println("[before] first = " + this.first);
+    this.first = first;
+    System.out.println("[after] first = " + this.first);
+    return this;
+  }
+
+  public PairBuilder<F, S> setSecond(S second) {
+    System.out.println("[before] second = " + this.second);
+    this.second = second;
+    System.out.println("[after] second = " + this.second);
+    return this;
+  }
+
+  public Pair<F, S> build() {
+    return new Pair<>(first, second);
+  }
+}
+
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/builders/Tuple.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/builders/Tuple.java
new file mode 100644
index 0000000..3a77cc2
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/builders/Tuple.java
@@ -0,0 +1,39 @@
+// 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.optimize.classinliner.builders;
+
+public class Tuple {
+  public boolean z;
+  public byte b;
+  public short s;
+  public char c;
+  public int i;
+  public long l;
+  public float f;
+  public double d;
+  public Object o;
+
+  Tuple() {
+  }
+
+  Tuple(boolean z, byte b, short s, char c, int i, long l, float f, double d, Object o) {
+    this.z = z;
+    this.b = b;
+    this.s = s;
+    this.c = c;
+    this.i = i;
+    this.l = l;
+    this.f = f;
+    this.d = d;
+    this.o = o;
+  }
+
+  @Override
+  public String toString() {
+    return "Tuple1(" + z + ", " + b + ", " + s + ", " +
+        ((int) c) + ", " + i + ", " + l + ", " + f + ", " +
+        d + ", " + (o == null ? "<null>" : o) + ")";
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InvokeInterfaceToInvokeVirtualTest.java b/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InvokeInterfaceToInvokeVirtualTest.java
index 57d694d..86c15a2 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InvokeInterfaceToInvokeVirtualTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/devirtualize/InvokeInterfaceToInvokeVirtualTest.java
@@ -87,4 +87,4 @@
     assertEquals(0, artOutput.exitCode);
     assertEquals(javaOutput.stdout.trim(), artOutput.stdout.trim());
   }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/com/android/tools/r8/jdwp/RunJdwpTests.java b/src/test/java/com/android/tools/r8/jdwp/RunJdwpTests.java
index bdedf43..3028525 100644
--- a/src/test/java/com/android/tools/r8/jdwp/RunJdwpTests.java
+++ b/src/test/java/com/android/tools/r8/jdwp/RunJdwpTests.java
@@ -16,6 +16,7 @@
 import com.android.tools.r8.ToolHelper.DexVm.Version;
 import com.android.tools.r8.ToolHelper.ProcessResult;
 import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.TestDescriptionWatcher;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import java.io.File;
@@ -30,6 +31,7 @@
 import org.junit.Assume;
 import org.junit.BeforeClass;
 import org.junit.ClassRule;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
 
@@ -267,6 +269,9 @@
   @ClassRule
   public static TemporaryFolder temp = ToolHelper.getTemporaryFolderForTest();
 
+  @Rule
+  public TestDescriptionWatcher watcher = new TestDescriptionWatcher();
+
   @BeforeClass
   public static void compileLibraries() throws Exception {
     // Selects appropriate jar according to min api level for the selected runtime.
diff --git a/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java b/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
index c175e04..f99934e 100644
--- a/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
+++ b/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
@@ -223,7 +223,7 @@
 
   protected void runTest(String folder, String mainClass, String extraProguardRules,
       Consumer<InternalOptions> optionsConsumer, AndroidAppInspector inspector) throws Exception {
-    Assume.assumeTrue(ToolHelper.artSupported());
+    Assume.assumeTrue(ToolHelper.artSupported() || ToolHelper.compareAgaintsGoldenFiles());
 
     String proguardRules = buildProguardRules(mainClass);
     if (extraProguardRules != null) {
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java
index c8c8aec..73d1e50 100644
--- a/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java
@@ -10,7 +10,9 @@
 import com.android.tools.r8.utils.DexInspector;
 import com.android.tools.r8.utils.DexInspector.ClassSubject;
 import com.android.tools.r8.utils.DexInspector.MethodSubject;
+import com.android.tools.r8.utils.InternalOptions;
 import java.util.Collections;
+import java.util.function.Consumer;
 import org.junit.Test;
 
 public class R8KotlinDataClassTest extends AbstractR8KotlinTestBase {
@@ -33,13 +35,15 @@
   private static final MethodSignature COPY_DEFAULT_METHOD =
       TEST_DATA_CLASS.getCopyDefaultSignature();
 
+  private Consumer<InternalOptions> disableClassInliner = o -> o.enableClassInlining = false;
+
   @Test
   public void test_dataclass_gettersOnly() throws Exception {
     final String mainClassName = "dataclass.MainGettersOnlyKt";
     final MethodSignature testMethodSignature =
         new MethodSignature("testDataClassGetters", "void", Collections.emptyList());
     final String extraRules = keepClassMethod(mainClassName, testMethodSignature);
-    runTest("dataclass", mainClassName, extraRules, (app) -> {
+    runTest("dataclass", mainClassName, extraRules, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
       ClassSubject dataClass = checkClassIsKept(dexInspector, TEST_DATA_CLASS.getClassName());
 
@@ -74,7 +78,7 @@
     final MethodSignature testMethodSignature =
         new MethodSignature("testAllDataClassComponentFunctions", "void", Collections.emptyList());
     final String extraRules = keepClassMethod(mainClassName, testMethodSignature);
-    runTest("dataclass", mainClassName, extraRules, (app) -> {
+    runTest("dataclass", mainClassName, extraRules, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
       ClassSubject dataClass = checkClassIsKept(dexInspector, TEST_DATA_CLASS.getClassName());
 
@@ -109,7 +113,7 @@
     final MethodSignature testMethodSignature =
         new MethodSignature("testSomeDataClassComponentFunctions", "void", Collections.emptyList());
     final String extraRules = keepClassMethod(mainClassName, testMethodSignature);
-    runTest("dataclass", mainClassName, extraRules, (app) -> {
+    runTest("dataclass", mainClassName, extraRules, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
       ClassSubject dataClass = checkClassIsKept(dexInspector, TEST_DATA_CLASS.getClassName());
 
@@ -144,7 +148,7 @@
     final MethodSignature testMethodSignature =
         new MethodSignature("testDataClassCopy", "void", Collections.emptyList());
     final String extraRules = keepClassMethod(mainClassName, testMethodSignature);
-    runTest("dataclass", mainClassName, extraRules, (app) -> {
+    runTest("dataclass", mainClassName, extraRules, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
       ClassSubject dataClass = checkClassIsKept(dexInspector, TEST_DATA_CLASS.getClassName());
 
@@ -159,7 +163,7 @@
     final MethodSignature testMethodSignature =
         new MethodSignature("testDataClassCopyWithDefault", "void", Collections.emptyList());
     final String extraRules = keepClassMethod(mainClassName, testMethodSignature);
-    runTest("dataclass", mainClassName, extraRules, (app) -> {
+    runTest("dataclass", mainClassName, extraRules, disableClassInliner, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
       ClassSubject dataClass = checkClassIsKept(dexInspector, TEST_DATA_CLASS.getClassName());
 
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 e2dfb6d..46a439d 100644
--- a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingTest.java
+++ b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingTest.java
@@ -16,6 +16,7 @@
 import com.android.tools.r8.utils.DexInspector.InstructionSubject;
 import com.android.tools.r8.utils.DexInspector.InvokeInstructionSubject;
 import com.android.tools.r8.utils.DexInspector.MethodSubject;
+import com.android.tools.r8.utils.TestDescriptionWatcher;
 import com.google.common.collect.ImmutableList;
 import java.io.IOException;
 import java.nio.file.Path;
@@ -26,6 +27,7 @@
 import java.util.concurrent.ExecutionException;
 import java.util.function.Consumer;
 import org.junit.Assert;
+import org.junit.Assume;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
@@ -60,6 +62,9 @@
   @Rule
   public TemporaryFolder temp = ToolHelper.getTemporaryFolderForTest();
 
+  @Rule
+  public TestDescriptionWatcher watcher = new TestDescriptionWatcher();
+
   public MemberRebindingTest(TestConfiguration configuration) {
     this.kind = configuration.kind;
     originalDex = configuration.getDexPath();
@@ -319,9 +324,8 @@
 
   @Test
   public void memberRebindingTest() throws IOException, InterruptedException, ExecutionException {
-    if (!ToolHelper.artSupported()) {
-      return;
-    }
+    Assume.assumeTrue(ToolHelper.artSupported() || ToolHelper.compareAgaintsGoldenFiles());
+
     String out = temp.getRoot().getCanonicalPath();
     Path processed = Paths.get(out, "classes.dex");
 
diff --git a/src/test/java/com/android/tools/r8/resource/DataResourceTest.java b/src/test/java/com/android/tools/r8/resource/DataResourceTest.java
index 2df0612..66161e1 100644
--- a/src/test/java/com/android/tools/r8/resource/DataResourceTest.java
+++ b/src/test/java/com/android/tools/r8/resource/DataResourceTest.java
@@ -10,6 +10,7 @@
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.ToolHelper.ProcessResult;
 import com.android.tools.r8.utils.FileUtils;
+import com.android.tools.r8.utils.TestDescriptionWatcher;
 import java.io.IOException;
 import java.nio.file.Path;
 import java.nio.file.Paths;
@@ -23,6 +24,9 @@
   @Rule
   public TemporaryFolder temp = ToolHelper.getTemporaryFolderForTest();
 
+  @Rule
+  public TestDescriptionWatcher watcher = new TestDescriptionWatcher();
+
   @Test
   public void dataResourceTest() throws IOException, CompilationFailedException {
     String packageName = "dataresource";
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 f341969..c9488b4 100644
--- a/src/test/java/com/android/tools/r8/shaking/TreeShakingTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/TreeShakingTest.java
@@ -19,6 +19,7 @@
 import com.android.tools.r8.utils.DexInspector.FoundFieldSubject;
 import com.android.tools.r8.utils.DexInspector.FoundMethodSubject;
 import com.android.tools.r8.utils.ListUtils;
+import com.android.tools.r8.utils.TestDescriptionWatcher;
 import com.google.common.collect.ImmutableList;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -76,6 +77,9 @@
   @Rule
   public TemporaryFolder temp = ToolHelper.getTemporaryFolderForTest();
 
+  @Rule
+  public TestDescriptionWatcher watcher = new TestDescriptionWatcher();
+
   protected TreeShakingTest(
       String name, String mainClass, Frontend frontend, Backend backend, MinifyMode minify) {
     this.name = name;
@@ -204,7 +208,7 @@
       }
       return;
     }
-    if (!ToolHelper.artSupported()) {
+    if (!ToolHelper.artSupported() && !ToolHelper.compareAgaintsGoldenFiles()) {
       return;
     }
     Consumer<ArtCommandBuilder> extraArtArgs = builder -> {
diff --git a/src/test/java/com/android/tools/r8/utils/TestDescriptionWatcher.java b/src/test/java/com/android/tools/r8/utils/TestDescriptionWatcher.java
new file mode 100644
index 0000000..5295c0e
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/utils/TestDescriptionWatcher.java
@@ -0,0 +1,29 @@
+// 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.utils;
+
+import org.junit.rules.TestWatcher;
+import org.junit.runner.Description;
+
+/**
+ * This {@link TestWatcher} passes test description information
+ * (namely test class and method names) to the test framework
+ * via system properties.
+ */
+public class TestDescriptionWatcher extends TestWatcher {
+
+  @Override
+  protected void starting(Description description) {
+    System.setProperty("test_class_name", description.getClassName());
+    System.setProperty("test_name", description.getMethodName());
+    System.setProperty("reset_output_index", "true");
+  }
+
+  @Override
+  protected void finished(Description description) {
+    System.clearProperty("test_class_name");
+    System.clearProperty("test_name");
+  }
+
+}
diff --git a/tools/download_from_x20.py b/tools/download_from_x20.py
index 01ba4e1..5f64684 100755
--- a/tools/download_from_x20.py
+++ b/tools/download_from_x20.py
@@ -19,17 +19,10 @@
 def parse_options():
   return optparse.OptionParser().parse_args()
 
-def extract_dir(filename):
-  return filename[0:len(filename) - len('.tar.gz')]
-
-def unpack_archive(filename):
-  dest_dir = extract_dir(filename)
-  if os.path.exists(dest_dir):
-    print 'Deleting existing dir %s' % dest_dir
-    shutil.rmtree(dest_dir)
-  dirname = os.path.dirname(os.path.abspath(filename))
-  with tarfile.open(filename, 'r:gz') as tar:
-    tar.extractall(path=dirname)
+def download(src, dest):
+  print 'Downloading %s to %s' % (src, dest)
+  shutil.copyfile(src, dest)
+  utils.unpack_archive(dest)
 
 def Main():
   (options, args) = parse_options()
@@ -41,20 +34,18 @@
     sha1 = input_sha.readline()
   if os.path.exists(dest) and utils.get_sha1(dest) == sha1:
     print 'sha1 matches, not downloading'
-    dest_dir = extract_dir(dest)
+    dest_dir = utils.extract_dir(dest)
     if os.path.exists(dest_dir):
       print 'destination directory exists, no extraction'
     else:
-      unpack_archive(dest)
+      utils.unpack_archive(dest)
     return
   src = os.path.join(GMSCORE_DEPS, sha1)
   if not os.path.exists(src):
     print 'File (%s) does not exist on x20' % src
     print 'Maybe pass -Pno_internal to your gradle invocation'
     return 42
-  print 'Downloading %s to %s' % (src, dest)
-  shutil.copyfile(src, dest)
-  unpack_archive(dest)
+  download(src, dest)
 
 if __name__ == '__main__':
   sys.exit(Main())
diff --git a/tools/test.py b/tools/test.py
index ed99c1d..b92c8dc 100755
--- a/tools/test.py
+++ b/tools/test.py
@@ -15,6 +15,7 @@
 import utils
 import uuid
 import notify
+import upload_to_x20
 
 
 ALL_ART_VMS = ["default", "7.0.0", "6.0.1", "5.1.1", "4.4.4", "4.0.4"]
@@ -78,6 +79,13 @@
           ' Note that the directory will not be cleared before the test.')
   result.add_option('--java_home',
       help='Use a custom java version to run tests.')
+  result.add_option('--generate_golden_files_to',
+      help='Store dex files produced by tests in the specified directory.'
+           ' It is aimed to be read on platforms with no host runtime available'
+           ' for comparison.')
+  result.add_option('--use_golden_files_in',
+      help='Download golden files hierarchy for this commit in the specified'
+           ' location and use them instead of executing on host runtime.')
 
   return result.parse_args()
 
@@ -93,7 +101,7 @@
 def Main():
   (options, args) = ParseOptions()
 
-  gradle_args = []
+  gradle_args = ['--stacktrace']
   # Set all necessary Gradle properties and options first.
   if options.verbose:
     gradle_args.append('-Pprint_test_stdout')
@@ -134,7 +142,16 @@
       os.makedirs(options.test_dir)
   if options.java_home:
     gradle_args.append('-Dorg.gradle.java.home=' + options.java_home)
-
+  if options.generate_golden_files_to:
+    gradle_args.append('-Pgenerate_golden_files_to=' + options.generate_golden_files_to)
+    if not os.path.exists(options.generate_golden_files_to):
+      os.makedirs(options.generate_golden_files_to)
+    gradle_args.append('-PHEAD_sha1=' + utils.get_HEAD_sha1())
+  if options.use_golden_files_in:
+    gradle_args.append('-Puse_golden_files_in=' + options.use_golden_files_in)
+    if not os.path.exists(options.use_golden_files_in):
+      os.makedirs(options.use_golden_files_in)
+    gradle_args.append('-PHEAD_sha1=' + utils.get_HEAD_sha1())
   # Add Gradle tasks
   gradle_args.append('cleanTest')
   gradle_args.append('test')
@@ -146,12 +163,29 @@
     # Create Jacoco report after tests.
     gradle_args.append('jacocoTestReport')
 
+  if options.use_golden_files_in:
+    sha1 = '%s' % utils.get_HEAD_sha1()
+    with utils.ChangedWorkingDirectory(options.use_golden_files_in):
+      utils.download_file_from_cloud_storage(
+                                    'gs://r8-test-results/golden-files/%s.tar.gz' % sha1,
+                                    '%s.tar.gz' % sha1)
+      utils.unpack_archive('%s.tar.gz' % sha1)
+
+
   # Now run tests on selected runtime(s).
   vms_to_test = [options.dex_vm] if options.dex_vm != "all" else ALL_ART_VMS
   for art_vm in vms_to_test:
     vm_kind_to_test = "_" + options.dex_vm_kind if art_vm != "default" else ""
     return_code = gradle.RunGradle(gradle_args + ['-Pdex_vm=%s' % (art_vm + vm_kind_to_test)],
                                    throw_on_failure=False)
+
+    if options.generate_golden_files_to:
+      sha1 = '%s' % utils.get_HEAD_sha1()
+      with utils.ChangedWorkingDirectory(options.generate_golden_files_to):
+        archive = utils.create_archive(sha1)
+        utils.upload_file_to_cloud_storage(archive,
+                                           'gs://r8-test-results/golden-files/' + archive)
+
     if return_code != 0:
       if options.archive_failures and os.name != 'nt':
         archive_failures()
diff --git a/tools/upload_to_x20.py b/tools/upload_to_x20.py
index 1efacf5..2d08362 100755
--- a/tools/upload_to_x20.py
+++ b/tools/upload_to_x20.py
@@ -20,11 +20,10 @@
 def parse_options():
   return optparse.OptionParser().parse_args()
 
-def create_archive(name):
-  tarname = '%s.tar.gz' % name
-  with tarfile.open(tarname, 'w:gz') as tar:
-    tar.add(name)
-  return tarname
+def uploadFile(filename, dest):
+  print 'Uploading to %s' % dest
+  shutil.copyfile(filename, dest)
+  subprocess.check_call(['chmod', '664', dest])
 
 def Main():
   (options, args) = parse_options()
@@ -34,12 +33,10 @@
   if not name in os.listdir('.'):
     print 'You must be standing directly below the directory you are uploading'
     return 1
-  filename = create_archive(name)
+  filename = utils.create_archive(name)
   sha1 = utils.get_sha1(filename)
   dest = os.path.join(GMSCORE_DEPS, sha1)
-  print 'Uploading to %s' % dest
-  shutil.copyfile(filename, dest)
-  subprocess.check_call(['chmod', '664', dest])
+  uploadFile(filename, dest)
   sha1_file = '%s.sha1' % filename
   with open(sha1_file, 'w') as output:
     output.write(sha1)
diff --git a/tools/utils.py b/tools/utils.py
index 3aab572..859da97 100644
--- a/tools/utils.py
+++ b/tools/utils.py
@@ -10,6 +10,7 @@
 import shutil
 import subprocess
 import sys
+import tarfile
 import tempfile
 
 TOOLS_DIR = os.path.abspath(os.path.normpath(os.path.join(__file__, '..')))
@@ -71,6 +72,12 @@
       sha1.update(chunk)
   return sha1.hexdigest()
 
+def get_HEAD_sha1():
+  cmd = ['git', 'rev-parse', 'HEAD']
+  PrintCmd(cmd)
+  with ChangedWorkingDirectory(REPO_ROOT):
+    return subprocess.check_output(cmd).strip()
+
 def makedirs_if_needed(path):
   try:
     os.makedirs(path)
@@ -92,6 +99,29 @@
   PrintCmd(cmd)
   subprocess.check_call(cmd)
 
+def download_file_from_cloud_storage(source, destination):
+  cmd = ['gsutil.py', 'cp', source, destination]
+  PrintCmd(cmd)
+  subprocess.check_call(cmd)
+
+def create_archive(name):
+  tarname = '%s.tar.gz' % name
+  with tarfile.open(tarname, 'w:gz') as tar:
+    tar.add(name)
+  return tarname
+
+def extract_dir(filename):
+  return filename[0:len(filename) - len('.tar.gz')]
+
+def unpack_archive(filename):
+  dest_dir = extract_dir(filename)
+  if os.path.exists(dest_dir):
+    print 'Deleting existing dir %s' % dest_dir
+    shutil.rmtree(dest_dir)
+  dirname = os.path.dirname(os.path.abspath(filename))
+  with tarfile.open(filename, 'r:gz') as tar:
+    tar.extractall(path=dirname)
+
 # Note that gcs is eventually consistent with regards to list operations.
 # This is not a problem in our case, but don't ever use this method
 # for synchronization.