diff --git a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
index 90dfef0..dfda737 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -181,23 +181,29 @@
   public final DexString methodDescriptor = createString("Ljava/lang/reflect/Method;");
   public final DexString enumDescriptor = createString("Ljava/lang/Enum;");
   public final DexString annotationDescriptor = createString("Ljava/lang/annotation/Annotation;");
-  public final DexString throwableDescriptor = createString(throwableDescriptorString);
-  public final DexString exceptionInInitializerErrorDescriptor =
-      createString("Ljava/lang/ExceptionInInitializerError;");
   public final DexString objectsDescriptor = createString("Ljava/util/Objects;");
+
   public final DexString stringBuilderDescriptor = createString("Ljava/lang/StringBuilder;");
   public final DexString stringBufferDescriptor = createString("Ljava/lang/StringBuffer;");
+
   public final DexString varHandleDescriptor = createString("Ljava/lang/invoke/VarHandle;");
   public final DexString methodHandleDescriptor = createString("Ljava/lang/invoke/MethodHandle;");
   public final DexString methodTypeDescriptor = createString("Ljava/lang/invoke/MethodType;");
-
   public final DexString invocationHandlerDescriptor =
       createString("Ljava/lang/reflect/InvocationHandler;");
-  public final DexString npeDescriptor = createString("Ljava/lang/NullPointerException;");
   public final DexString proxyDescriptor = createString("Ljava/lang/reflect/Proxy;");
   public final DexString serviceLoaderDescriptor = createString("Ljava/util/ServiceLoader;");
   public final DexString listDescriptor = createString("Ljava/util/List;");
 
+  public final DexString throwableDescriptor = createString(throwableDescriptorString);
+  public final DexString illegalAccessErrorDescriptor =
+      createString("Ljava/lang/IllegalAccessError;");
+  public final DexString icceDescriptor = createString("Ljava/lang/IncompatibleClassChangeError;");
+  public final DexString exceptionInInitializerErrorDescriptor =
+      createString("Ljava/lang/ExceptionInInitializerError;");
+  public final DexString noSuchFieldErrorDescriptor = createString("Ljava/lang/NoSuchFieldError");
+  public final DexString npeDescriptor = createString("Ljava/lang/NullPointerException;");
+
   public final DexString intFieldUpdaterDescriptor =
       createString("Ljava/util/concurrent/atomic/AtomicIntegerFieldUpdater;");
   public final DexString longFieldUpdaterDescriptor =
@@ -243,9 +249,7 @@
   public final DexType classArrayType = createType(classArrayDescriptor);
   public final DexType enumType = createType(enumDescriptor);
   public final DexType annotationType = createType(annotationDescriptor);
-  public final DexType throwableType = createType(throwableDescriptor);
-  public final DexType exceptionInInitializerErrorType =
-      createType(exceptionInInitializerErrorDescriptor);
+
   public final DexType classType = createType(classDescriptor);
   public final DexType classLoaderType = createType(classLoaderDescriptor);
   public final DexType autoCloseableType = createType(autoCloseableDescriptor);
@@ -256,13 +260,19 @@
   public final DexType varHandleType = createType(varHandleDescriptor);
   public final DexType methodHandleType = createType(methodHandleDescriptor);
   public final DexType methodTypeType = createType(methodTypeDescriptor);
-
   public final DexType invocationHandlerType = createType(invocationHandlerDescriptor);
-  public final DexType npeType = createType(npeDescriptor);
   public final DexType proxyType = createType(proxyDescriptor);
   public final DexType serviceLoaderType = createType(serviceLoaderDescriptor);
   public final DexType listType = createType(listDescriptor);
 
+  public final DexType throwableType = createType(throwableDescriptor);
+  public final DexType illegalAccessErrorType = createType(illegalAccessErrorDescriptor);
+  public final DexType icceType = createType(icceDescriptor);
+  public final DexType exceptionInInitializerErrorType =
+      createType(exceptionInInitializerErrorDescriptor);
+  public final DexType noSuchFieldErrorType = createType(noSuchFieldErrorDescriptor);
+  public final DexType npeType = createType(npeDescriptor);
+
   public final StringBuildingMethods stringBuilderMethods =
       new StringBuildingMethods(stringBuilderType);
   public final StringBuildingMethods stringBufferMethods =
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/AbstractError.java b/src/main/java/com/android/tools/r8/ir/analysis/AbstractError.java
new file mode 100644
index 0000000..dcfd5c5
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/AbstractError.java
@@ -0,0 +1,56 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.ir.analysis;
+
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexType;
+
+// Note that this is not what D8/R8 can throw.
+//
+// Finer-grained abstraction of Throwable that an instruction can throw if any.
+//
+//       Top        // throwing, but not quite sure what it would be.
+//    /   |    \
+//  NPE  ICCE  ...  // specific exceptions.
+//    \   |    /
+//      Bottom      // not throwing.
+public class AbstractError {
+
+  private static final AbstractError TOP = new AbstractError();
+  private static final AbstractError BOTTOM = new AbstractError();
+
+  private DexType simulatedError;
+
+  private AbstractError() {}
+
+  private AbstractError(DexType throwable) {
+    simulatedError = throwable;
+  }
+
+  public static AbstractError top() {
+    return TOP;
+  }
+
+  public static AbstractError bottom() {
+    return BOTTOM;
+  }
+
+  public static AbstractError specific(DexType throwable) {
+    return new AbstractError(throwable);
+  }
+
+  public boolean isThrowing() {
+    return this != BOTTOM;
+  }
+
+  public DexType getSpecificError(DexItemFactory factory) {
+    assert isThrowing();
+    if (simulatedError != null) {
+      return simulatedError;
+    }
+    assert this == TOP;
+    return factory.throwableType;
+  }
+
+}
diff --git a/src/main/java/com/android/tools/r8/ir/code/ArrayGet.java b/src/main/java/com/android/tools/r8/ir/code/ArrayGet.java
index 3e2af3d..331a9ac 100644
--- a/src/main/java/com/android/tools/r8/ir/code/ArrayGet.java
+++ b/src/main/java/com/android/tools/r8/ir/code/ArrayGet.java
@@ -240,6 +240,16 @@
   }
 
   @Override
+  public boolean throwsOnNullInput() {
+    return true;
+  }
+
+  @Override
+  public Value getNonNullInput() {
+    return array();
+  }
+
+  @Override
   public void constrainType(TypeConstraintResolver constraintResolver) {
     constraintResolver.constrainArrayMemberType(type, dest(), array(), t -> type = t);
   }
diff --git a/src/main/java/com/android/tools/r8/ir/code/ArrayLength.java b/src/main/java/com/android/tools/r8/ir/code/ArrayLength.java
index 061aa53..6e6a9f8 100644
--- a/src/main/java/com/android/tools/r8/ir/code/ArrayLength.java
+++ b/src/main/java/com/android/tools/r8/ir/code/ArrayLength.java
@@ -119,4 +119,15 @@
   public boolean throwsNpeIfValueIsNull(Value value, DexItemFactory dexItemFactory) {
     return array() == value;
   }
+
+  @Override
+  public boolean throwsOnNullInput() {
+    return true;
+  }
+
+  @Override
+  public Value getNonNullInput() {
+    return array();
+  }
+
 }
diff --git a/src/main/java/com/android/tools/r8/ir/code/ArrayPut.java b/src/main/java/com/android/tools/r8/ir/code/ArrayPut.java
index a76bf42..fa3a846 100644
--- a/src/main/java/com/android/tools/r8/ir/code/ArrayPut.java
+++ b/src/main/java/com/android/tools/r8/ir/code/ArrayPut.java
@@ -189,6 +189,16 @@
   }
 
   @Override
+  public boolean throwsOnNullInput() {
+    return true;
+  }
+
+  @Override
+  public Value getNonNullInput() {
+    return array();
+  }
+
+  @Override
   public void constrainType(TypeConstraintResolver constraintResolver) {
     constraintResolver.constrainArrayMemberType(type, value(), array(), t -> type = t);
   }
diff --git a/src/main/java/com/android/tools/r8/ir/code/FieldInstruction.java b/src/main/java/com/android/tools/r8/ir/code/FieldInstruction.java
index 2900491..ac7d337 100644
--- a/src/main/java/com/android/tools/r8/ir/code/FieldInstruction.java
+++ b/src/main/java/com/android/tools/r8/ir/code/FieldInstruction.java
@@ -3,7 +3,14 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.ir.code;
 
+import static com.android.tools.r8.optimize.MemberRebindingAnalysis.isMemberVisibleFromOriginalContext;
+
+import com.android.tools.r8.graph.AppInfo;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.analysis.AbstractError;
 import java.util.Collections;
 import java.util.List;
 
@@ -42,6 +49,53 @@
   }
 
   @Override
+  public AbstractError instructionInstanceCanThrow(
+      AppView<? extends AppInfo> appView, DexType context) {
+    // Not applicable for D8.
+    if (!appView.enableWholeProgramOptimizations()) {
+      return AbstractError.top();
+    }
+
+    // TODO(b/123857022): Should be possible to use definitionFor().
+    DexEncodedField resolvedField = appView.appInfo().resolveField(getField());
+    // * NoSuchFieldError (resolution failure).
+    if (resolvedField == null) {
+      return AbstractError.specific(appView.dexItemFactory().noSuchFieldErrorType);
+    }
+    // * IncompatibleClassChangeError (instance-* for static field and vice versa).
+    if (resolvedField.isStaticMember()) {
+      if (isInstanceGet() || isInstancePut()) {
+        return AbstractError.specific(appView.dexItemFactory().icceType);
+      }
+    } else {
+      if (isStaticGet() || isStaticPut()) {
+        return AbstractError.specific(appView.dexItemFactory().icceType);
+      }
+    }
+    // * IllegalAccessError (not visible from the access context).
+    if (!isMemberVisibleFromOriginalContext(
+        appView, context, resolvedField.field.holder, resolvedField.accessFlags)) {
+      return AbstractError.specific(appView.dexItemFactory().illegalAccessErrorType);
+    }
+    // * NullPointerException (null receiver).
+    if (isInstanceGet() || isInstancePut()) {
+      Value receiver = inValues.get(0);
+      if (receiver.isAlwaysNull(appView) || receiver.typeLattice.isNullable()) {
+        return AbstractError.specific(appView.dexItemFactory().npeType);
+      }
+    }
+    // May trigger <clinit> that may have side effects.
+    if (field.holder.classInitializationMayHaveSideEffects(
+        appView,
+        // Types that are a super type of `context` are guaranteed to be initialized already.
+        type -> appView.isSubtype(context, type).isTrue())) {
+      return AbstractError.top();
+    }
+
+    return AbstractError.bottom();
+  }
+
+  @Override
   public boolean hasInvariantOutType() {
     // TODO(jsjeon): what if the target field is known to be non-null?
     return true;
diff --git a/src/main/java/com/android/tools/r8/ir/code/InstanceGet.java b/src/main/java/com/android/tools/r8/ir/code/InstanceGet.java
index 86d549d..6bb754f 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InstanceGet.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InstanceGet.java
@@ -4,8 +4,6 @@
 
 package com.android.tools.r8.ir.code;
 
-import static com.android.tools.r8.optimize.MemberRebindingAnalysis.isMemberVisibleFromOriginalContext;
-
 import com.android.tools.r8.cf.LoadStoreHelper;
 import com.android.tools.r8.cf.TypeVerificationHelper;
 import com.android.tools.r8.cf.code.CfFieldInstruction;
@@ -20,7 +18,6 @@
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexType;
@@ -105,30 +102,22 @@
   }
 
   @Override
-  public boolean canBeDeadCode(AppView<? extends AppInfo> appView, IRCode code) {
-    // Not applicable for D8.
-    if (!appView.enableWholeProgramOptimizations()) {
-      return false;
-    }
+  public boolean instructionMayHaveSideEffects(
+      AppView<? extends AppInfo> appView, DexType context) {
+    return instructionInstanceCanThrow(appView, context).isThrowing();
+  }
 
+  @Override
+  public boolean canBeDeadCode(AppView<? extends AppInfo> appView, IRCode code) {
     // instance-get can be dead code as long as it cannot have any of the following:
     // * NoSuchFieldError (resolution failure)
+    // * IncompatibleClassChangeError (instance-* instruction for static fields)
     // * IllegalAccessError (not visible from the access context)
-    // * NullPointerException (null receiver).
-    // TODO(b/123857022): Should be possible to use definitionFor().
-    AppInfo appInfo = appView.appInfo();
-    DexEncodedField resolvedField = appInfo.resolveField(getField());
-    if (resolvedField == null) {
-      return false;
-    }
-    if (!isMemberVisibleFromOriginalContext(
-        appView,
-        code.method.method.holder,
-        resolvedField.field.holder,
-        resolvedField.accessFlags)) {
-      return false;
-    }
-    return object().getTypeLattice().nullability().isDefinitelyNotNull();
+    // * NullPointerException (null receiver)
+    boolean canBeDeadCode = !instructionMayHaveSideEffects(appView, code.method.method.holder);
+    assert appView.enableWholeProgramOptimizations() || !canBeDeadCode
+        : "Expected instance-get instruction to have side effects in D8";
+    return canBeDeadCode;
   }
 
   @Override
@@ -200,6 +189,16 @@
   }
 
   @Override
+  public boolean throwsOnNullInput() {
+    return true;
+  }
+
+  @Override
+  public Value getNonNullInput() {
+    return object();
+  }
+
+  @Override
   public boolean definitelyTriggersClassInitialization(
       DexType clazz,
       DexType context,
diff --git a/src/main/java/com/android/tools/r8/ir/code/InstancePut.java b/src/main/java/com/android/tools/r8/ir/code/InstancePut.java
index e4b062f..20c4733 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InstancePut.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InstancePut.java
@@ -174,6 +174,16 @@
   }
 
   @Override
+  public boolean throwsOnNullInput() {
+    return true;
+  }
+
+  @Override
+  public Value getNonNullInput() {
+    return object();
+  }
+
+  @Override
   public boolean definitelyTriggersClassInitialization(
       DexType clazz,
       DexType context,
diff --git a/src/main/java/com/android/tools/r8/ir/code/Instruction.java b/src/main/java/com/android/tools/r8/ir/code/Instruction.java
index dcbef34..bc9bc6b 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Instruction.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Instruction.java
@@ -12,6 +12,7 @@
 import com.android.tools.r8.graph.DebugLocalInfo;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.analysis.AbstractError;
 import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.AnalysisAssumption;
 import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.Query;
 import com.android.tools.r8.ir.analysis.constant.Bottom;
@@ -514,8 +515,15 @@
     return instructionInstanceCanThrow();
   }
 
+  public AbstractError instructionInstanceCanThrow(
+      AppView<? extends AppInfo> appView, DexType context) {
+    return instructionInstanceCanThrow() ? AbstractError.top() : AbstractError.bottom();
+  }
+
   /** Returns true is this instruction can be treated as dead code if its outputs are not used. */
   public boolean canBeDeadCode(AppView<? extends AppInfo> appView, IRCode code) {
+    // TODO(b/129530569): instructions with fine-grained side effect analysis may use:
+    // return !instructionMayHaveSideEffects(appView, code.method.method.holder);
     return !instructionInstanceCanThrow();
   }
 
@@ -1264,6 +1272,21 @@
     return false;
   }
 
+  // Any instructions that override `throwsNpeIfValueIsNull` should override this too.
+  // `throw` instruction is also throwing if the input is null. However, this util and the below
+  // one are used to insert Assume instruction if input is known to be non-null or replace the
+  // instruction with `throw null`. In either case, nullability of `throw` does not add anything
+  // new: `throw X` with null reference X has the same effect as `throw null`; `throw X` with
+  // non-null reference X ends, hence having non-null X after that instruction is non-sense.
+  public boolean throwsOnNullInput() {
+    return false;
+  }
+
+  // Any instructions that override `throwsOnNullInput` should override this too.
+  public Value getNonNullInput() {
+    throw new Unreachable("Should conform to throwsOnNullInput.");
+  }
+
   /**
    * Indicates whether the instruction triggers the class initialization (i.e. the <clinit> method)
    * of the given class at runtime execution.
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeMethodWithReceiver.java b/src/main/java/com/android/tools/r8/ir/code/InvokeMethodWithReceiver.java
index 1ca8df7..2e15003 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeMethodWithReceiver.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeMethodWithReceiver.java
@@ -48,6 +48,16 @@
   }
 
   @Override
+  public boolean throwsOnNullInput() {
+    return true;
+  }
+
+  @Override
+  public Value getNonNullInput() {
+    return getReceiver();
+  }
+
+  @Override
   public boolean verifyTypes(AppView<? extends AppInfo> appView) {
     assert super.verifyTypes(appView);
 
diff --git a/src/main/java/com/android/tools/r8/ir/code/Monitor.java b/src/main/java/com/android/tools/r8/ir/code/Monitor.java
index 60b99f8..8d691db 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Monitor.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Monitor.java
@@ -134,4 +134,14 @@
   public boolean throwsNpeIfValueIsNull(Value value, DexItemFactory dexItemFactory) {
     return object() == value;
   }
+
+  @Override
+  public boolean throwsOnNullInput() {
+    return true;
+  }
+
+  @Override
+  public Value getNonNullInput() {
+    return object();
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/code/StaticGet.java b/src/main/java/com/android/tools/r8/ir/code/StaticGet.java
index 328b2f2..6c48db2 100644
--- a/src/main/java/com/android/tools/r8/ir/code/StaticGet.java
+++ b/src/main/java/com/android/tools/r8/ir/code/StaticGet.java
@@ -3,8 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.ir.code;
 
-import static com.android.tools.r8.optimize.MemberRebindingAnalysis.isMemberVisibleFromOriginalContext;
-
 import com.android.tools.r8.cf.LoadStoreHelper;
 import com.android.tools.r8.cf.TypeVerificationHelper;
 import com.android.tools.r8.cf.code.CfFieldInstruction;
@@ -19,7 +17,6 @@
 import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis;
@@ -98,36 +95,22 @@
   }
 
   @Override
-  public boolean canBeDeadCode(AppView<? extends AppInfo> appView, IRCode code) {
-    // Not applicable for D8.
-    if (!appView.enableWholeProgramOptimizations()) {
-      return false;
-    }
+  public boolean instructionMayHaveSideEffects(
+      AppView<? extends AppInfo> appView, DexType context) {
+    return instructionInstanceCanThrow(appView, context).isThrowing();
+  }
 
+  @Override
+  public boolean canBeDeadCode(AppView<? extends AppInfo> appView, IRCode code) {
     // static-get can be dead as long as it cannot have any of the following:
     // * NoSuchFieldError (resolution failure)
+    // * IncompatibleClassChangeError (static-* instruction for instance fields)
     // * IllegalAccessError (not visible from the access context)
     // * side-effects in <clinit>
-    // TODO(b/123857022): Should be possible to use definitionFor().
-    AppInfo appInfo = appView.appInfo();
-    DexEncodedField resolvedField = appInfo.resolveField(getField());
-    if (resolvedField == null) {
-      return false;
-    }
-    if (!isMemberVisibleFromOriginalContext(
-        appView,
-        code.method.method.holder,
-        resolvedField.field.holder,
-        resolvedField.accessFlags)) {
-      return false;
-    }
-    DexType context = code.method.method.holder;
-    return !getField()
-        .holder
-        .classInitializationMayHaveSideEffects(
-            appInfo,
-            // Types that are a super type of `context` are guaranteed to be initialized already.
-            type -> appView.isSubtype(context, type).isTrue());
+    boolean canBeDeadCode = !instructionMayHaveSideEffects(appView, code.method.method.holder);
+    assert appView.enableWholeProgramOptimizations() || !canBeDeadCode
+        : "Expected static-get instruction to have side effects in D8";
+    return canBeDeadCode;
   }
 
   @Override
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 2e72732..bfdbd88 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
@@ -935,7 +935,7 @@
       devirtualizer.devirtualizeInvokeInterface(code, method.method.holder);
     }
     if (uninstantiatedTypeOptimization != null) {
-      uninstantiatedTypeOptimization.rewrite(method, code);
+      uninstantiatedTypeOptimization.rewrite(code);
     }
 
     assert code.verifyTypes(appView);
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/NonNullTracker.java b/src/main/java/com/android/tools/r8/ir/optimize/NonNullTracker.java
index fffd3da..9d493dc 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/NonNullTracker.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/NonNullTracker.java
@@ -5,7 +5,6 @@
 
 import static com.android.tools.r8.ir.code.DominatorTree.Assumption.MAY_HAVE_UNREACHABLE_BLOCKS;
 
-import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexEncodedMethod;
@@ -25,7 +24,6 @@
 import com.android.tools.r8.ir.code.Phi;
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.conversion.OptimizationFeedback;
-import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Sets;
 import it.unimi.dsi.fastutil.ints.IntArrayList;
@@ -49,36 +47,6 @@
     this.appView = appView;
   }
 
-  @VisibleForTesting
-  static boolean throwsOnNullInput(Instruction instruction) {
-    return (instruction.isInvokeMethodWithReceiver() && !instruction.isInvokeDirect())
-        || instruction.isInstanceGet()
-        || instruction.isInstancePut()
-        || instruction.isArrayGet()
-        || instruction.isArrayPut()
-        || instruction.isArrayLength()
-        || instruction.isMonitor();
-  }
-
-  private Value getNonNullInput(Instruction instruction) {
-    if (instruction.isInvokeMethodWithReceiver()) {
-      return instruction.asInvokeMethodWithReceiver().getReceiver();
-    } else if (instruction.isInstanceGet()) {
-      return instruction.asInstanceGet().object();
-    } else if (instruction.isInstancePut()) {
-      return instruction.asInstancePut().object();
-    } else if (instruction.isArrayGet()) {
-      return instruction.asArrayGet().array();
-    } else if (instruction.isArrayPut()) {
-      return instruction.asArrayPut().array();
-    } else if (instruction.isArrayLength()) {
-      return instruction.asArrayLength().array();
-    } else if (instruction.isMonitor()) {
-      return instruction.asMonitor().object();
-    }
-    throw new Unreachable("Should conform to throwsOnNullInput.");
-  }
-
   public void addNonNull(IRCode code) {
     addNonNullInPart(code, code.listIterator(), Predicates.alwaysTrue());
   }
@@ -114,10 +82,10 @@
             knownToBeNonNullValues.add(knownToBeNonNullValue);
           }
         }
-        if (throwsOnNullInput(current)) {
-          Value knownToBeNonNullValue = getNonNullInput(current);
-          if (isNonNullCandidate(knownToBeNonNullValue)) {
-            knownToBeNonNullValues.add(knownToBeNonNullValue);
+        if (current.throwsOnNullInput()) {
+          Value couldBeNonNull = current.getNonNullInput();
+          if (isNonNullCandidate(couldBeNonNull)) {
+            knownToBeNonNullValues.add(couldBeNonNull);
           }
         }
         if (current.isInvokeMethod() && !current.isInvokePolymorphic()) {
@@ -365,8 +333,8 @@
     return predecessorIndexes;
   }
 
-  private boolean isNonNullCandidate(Value knownToBeNonNullValue) {
-    TypeLatticeElement typeLattice = knownToBeNonNullValue.getTypeLattice();
+  private static boolean isNonNullCandidate(Value couldBeNonNullValue) {
+    TypeLatticeElement typeLattice = couldBeNonNullValue.getTypeLattice();
     return typeLattice.isReference() && !typeLattice.isNullType() && typeLattice.isNullable();
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/UninstantiatedTypeOptimization.java b/src/main/java/com/android/tools/r8/ir/optimize/UninstantiatedTypeOptimization.java
index 31ae148..40f20ed 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/UninstantiatedTypeOptimization.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/UninstantiatedTypeOptimization.java
@@ -8,6 +8,7 @@
 import static com.android.tools.r8.ir.optimize.UninstantiatedTypeOptimization.Strategy.DISALLOW_ARGUMENT_REMOVAL;
 
 import com.android.tools.r8.graph.AppInfo;
+import com.android.tools.r8.graph.AppInfoWithSubtyping;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexEncodedField;
@@ -23,6 +24,7 @@
 import com.android.tools.r8.graph.GraphLense.RewrittenPrototypeDescription.RemovedArgumentInfo;
 import com.android.tools.r8.graph.GraphLense.RewrittenPrototypeDescription.RemovedArgumentsInfo;
 import com.android.tools.r8.graph.TopDownClassHierarchyTraversal;
+import com.android.tools.r8.ir.analysis.AbstractError;
 import com.android.tools.r8.ir.analysis.type.Nullability;
 import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
 import com.android.tools.r8.ir.code.BasicBlock;
@@ -104,8 +106,10 @@
   private final AppView<AppInfoWithLiveness> appView;
 
   private int numberOfInstanceGetOrInstancePutWithNullReceiver = 0;
+  private int numberOfArrayInstructionsWithNullArray = 0;
   private int numberOfInvokesWithNullArgument = 0;
   private int numberOfInvokesWithNullReceiver = 0;
+  private int numberOfMonitorWithNullReceiver = 0;
 
   public UninstantiatedTypeOptimization(AppView<AppInfoWithLiveness> appView) {
     this.appView = appView;
@@ -349,7 +353,7 @@
         method.holder, dexItemFactory.createProto(newReturnType, newParameters), method.name);
   }
 
-  public void rewrite(DexEncodedMethod method, IRCode code) {
+  public void rewrite(IRCode code) {
     Set<BasicBlock> blocksToBeRemoved = Sets.newIdentityHashSet();
     ListIterator<BasicBlock> blockIterator = code.listIterator();
     while (blockIterator.hasNext()) {
@@ -360,22 +364,35 @@
       InstructionListIterator instructionIterator = block.listIterator();
       while (instructionIterator.hasNext()) {
         Instruction instruction = instructionIterator.next();
-        if (instruction.isFieldInstruction()) {
-          if (instruction.isInstanceGet() || instruction.isInstancePut()) {
-            rewriteInstanceFieldInstruction(
-                instruction.asFieldInstruction(),
-                blockIterator,
-                instructionIterator,
-                code,
-                blocksToBeRemoved);
-          } else {
-            rewriteStaticFieldInstruction(
-                instruction.asFieldInstruction(),
-                blockIterator,
-                instructionIterator,
-                code,
-                blocksToBeRemoved);
+        if (instruction.throwsOnNullInput()) {
+          Value couldBeNullValue = instruction.getNonNullInput();
+          if (isThrowNullCandidate(
+              couldBeNullValue, instruction, appView, code.method.method.holder)) {
+            if (instruction.isInstanceGet() || instruction.isInstancePut()) {
+              ++numberOfInstanceGetOrInstancePutWithNullReceiver;
+            } else if (instruction.isInvokeMethodWithReceiver()) {
+              ++numberOfInvokesWithNullReceiver;
+            } else if (instruction.isArrayGet()
+                || instruction.isArrayPut()
+                || instruction.isArrayLength()) {
+              ++numberOfArrayInstructionsWithNullArray;
+            } else if (instruction.isMonitor()) {
+              ++numberOfMonitorWithNullReceiver;
+            } else {
+              assert false;
+            }
+            instructionIterator.replaceCurrentInstructionWithThrowNull(
+                appView, code, blockIterator, blocksToBeRemoved);
+            continue;
           }
+        }
+        if (instruction.isFieldInstruction()) {
+          rewriteFieldInstruction(
+              instruction.asFieldInstruction(),
+              blockIterator,
+              instructionIterator,
+              code,
+              blocksToBeRemoved);
         } else if (instruction.isInvokeMethod()) {
           rewriteInvoke(
               instruction.asInvokeMethod(),
@@ -392,6 +409,29 @@
     assert code.isConsistentSSA();
   }
 
+  private static boolean isThrowNullCandidate(
+      Value couldBeNullValue,
+      Instruction current,
+      AppView<? extends AppInfoWithSubtyping> appView,
+      DexType context) {
+    if (!couldBeNullValue.isAlwaysNull(appView)) {
+      return false;
+    }
+    if (current.isFieldInstruction()) {
+      // Other resolution-related errors come first.
+      AbstractError abstractError =
+          current.asFieldInstruction().instructionInstanceCanThrow(appView, context);
+      if (abstractError.isThrowing()
+          && abstractError.getSpecificError(appView.dexItemFactory())
+              != appView.dexItemFactory().npeType) {
+        // We can't replace the current instruction with `throw null` if it may throw another
+        // Error/Exception than NullPointerException.
+        return false;
+      }
+    }
+    return true;
+  }
+
   public void logResults() {
     assert Log.ENABLED;
     Log.info(
@@ -399,50 +439,19 @@
         "Number of instance-get/instance-put with null receiver: %s",
         numberOfInstanceGetOrInstancePutWithNullReceiver);
     Log.info(
+        getClass(),
+        "Number of array instructions with null reference: %s",
+        numberOfArrayInstructionsWithNullArray);
+    Log.info(
         getClass(), "Number of invokes with null argument: %s", numberOfInvokesWithNullArgument);
     Log.info(
         getClass(), "Number of invokes with null receiver: %s", numberOfInvokesWithNullReceiver);
+    Log.info(
+        getClass(), "Number of monitor with null receiver: %s", numberOfMonitorWithNullReceiver);
   }
 
-  private void rewriteInstanceFieldInstruction(
-      FieldInstruction instruction,
-      ListIterator<BasicBlock> blockIterator,
-      InstructionListIterator instructionIterator,
-      IRCode code,
-      Set<BasicBlock> blocksToBeRemoved) {
-    assert instruction.isInstanceGet() || instruction.isInstancePut();
-    boolean replacedByThrowNull = false;
-
-    Value receiver = instruction.inValues().get(0);
-    if (receiver.isAlwaysNull(appView)) {
-      // Unable to rewrite instruction if the receiver is defined from "const-number 0", since this
-      // would lead to an IncompatibleClassChangeError (see MemberResolutionTest#lookupStaticField-
-      // WithFieldGetFromNullReferenceDirectly).
-      if (!receiver.getTypeLattice().isDefinitelyNull()) {
-        instructionIterator.replaceCurrentInstructionWithThrowNull(
-            appView, code, blockIterator, blocksToBeRemoved);
-        ++numberOfInstanceGetOrInstancePutWithNullReceiver;
-        replacedByThrowNull = true;
-      }
-    }
-
-    if (!replacedByThrowNull) {
-      rewriteFieldInstruction(
-          instruction, blockIterator, instructionIterator, code, blocksToBeRemoved);
-    }
-  }
-
-  private void rewriteStaticFieldInstruction(
-      FieldInstruction instruction,
-      ListIterator<BasicBlock> blockIterator,
-      InstructionListIterator instructionIterator,
-      IRCode code,
-      Set<BasicBlock> blocksToBeRemoved) {
-    assert instruction.isStaticGet() || instruction.isStaticPut();
-    rewriteFieldInstruction(
-        instruction, blockIterator, instructionIterator, code, blocksToBeRemoved);
-  }
-
+  // instance-{get|put} with a null receiver has already been rewritten to `throw null`.
+  // At this point, field-instruction whose target field type is uninstantiated will be handled.
   private void rewriteFieldInstruction(
       FieldInstruction instruction,
       ListIterator<BasicBlock> blockIterator,
@@ -451,13 +460,18 @@
       Set<BasicBlock> blocksToBeRemoved) {
     DexType fieldType = instruction.getField().type;
     if (fieldType.isAlwaysNull(appView)) {
-      // Before trying to remove this instruction, we need to be sure that the field actually
-      // exists. Otherwise this instruction would throw a NoSuchFieldError exception.
-      DexEncodedField field = appView.definitionFor(instruction.getField());
-      if (field == null) {
+      AbstractError abstractError =
+          instruction.instructionInstanceCanThrow(appView, code.method.method.holder);
+      if (abstractError.isThrowing()) {
         return;
       }
 
+      // TODO(b/123857022): Should be possible to use definitionFor().
+      DexEncodedField field = appView.appInfo().resolveField(instruction.getField());
+      if (field == null) {
+        assert false : "Expected field-instruction with non-existent field to throw";
+        return;
+      }
       // We also need to be sure that this field instruction cannot trigger static class
       // initialization.
       if (field.field.holder != code.method.method.holder) {
@@ -497,22 +511,16 @@
     }
   }
 
+  // invoke instructions with a null receiver has already been rewritten to `throw null`.
+  // At this point, we attempt to explore non-null-param-or-throw optimization info and replace
+  // the invocation with `throw null` if an argument is known to be null and the method is going to
+  // throw for that null argument.
   private void rewriteInvoke(
       InvokeMethod invoke,
       ListIterator<BasicBlock> blockIterator,
       InstructionListIterator instructionIterator,
       IRCode code,
       Set<BasicBlock> blocksToBeRemoved) {
-    if (invoke.isInvokeMethodWithReceiver()) {
-      Value receiver = invoke.asInvokeMethodWithReceiver().getReceiver();
-      if (receiver.isAlwaysNull(appView)) {
-        instructionIterator.replaceCurrentInstructionWithThrowNull(
-            appView, code, blockIterator, blocksToBeRemoved);
-        ++numberOfInvokesWithNullReceiver;
-        return;
-      }
-    }
-
     DexEncodedMethod target =
         invoke.lookupSingleTarget(appView.appInfo(), code.method.method.holder);
     if (target == null) {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/AlwaysThrowNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/AlwaysThrowNullTest.java
new file mode 100644
index 0000000..cc5893c
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/AlwaysThrowNullTest.java
@@ -0,0 +1,254 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.ir.optimize;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.D8TestRunResult;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NeverPropagateValue;
+import com.android.tools.r8.R8TestRunResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRunResult;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.InstructionSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Streams;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+class AlwaysThrowNullTestClass {
+  @NeverMerge
+  static class Base {
+    Object dead;
+
+    void foo() {
+      System.out.println("Base::foo");
+    }
+  }
+
+  static class Uninitialized extends Base {
+  }
+
+  @NeverPropagateValue
+  @NeverInline
+  static void uninstantiatedInstancePutWithNPEGuard(Uninitialized arg) {
+    try {
+      arg.dead = new Object();
+    } catch (NullPointerException npe) {
+      System.out.println("Expected NPE");
+    }
+  }
+
+  @NeverPropagateValue
+  @NeverInline
+  static void uninstantiatedInstancePutWithOtherGuard(Uninitialized arg) {
+    try {
+      arg.dead = new Object();
+    } catch (IllegalArgumentException e) {
+      fail("Unexpected exception kind");
+    }
+  }
+
+  @NeverPropagateValue
+  @NeverInline
+  static void uninstantiatedInstanceInvoke(Uninitialized arg) {
+    arg.foo();
+    // Dead code.
+    System.out.println("invoke-virtual with null receiver: " + arg.dead.toString());
+  }
+
+  static Object nullObject() {
+    return null;
+  }
+
+  @NeverPropagateValue
+  @NeverInline
+  static void nullReferenceInvoke() {
+    try {
+      Object o = nullObject();
+      o.hashCode();
+      // Dead code.
+      System.out.println("invoke-virtual with null receiver: " + o.toString());
+    } catch (NullPointerException npe) {
+      System.out.println("Expected NPE");
+    }
+  }
+
+  @NeverPropagateValue
+  @NeverInline
+  static void uninstantiatedInstancePut(Uninitialized arg) {
+    arg.dead = new Object();
+    // Dead code.
+    System.out.println("instance-put with null receiver: " + arg.dead.toString());
+  }
+
+  @NeverPropagateValue
+  @NeverInline
+  static void uninstantiatedInstanceGet(Uninitialized arg) {
+    Object dead = arg.dead;
+    // Dead code.
+    System.out.println("instance-get with null receiver: " + dead.toString());
+  }
+
+  public static void main(String[] args) {
+    Base b = new Base();
+    try {
+      uninstantiatedInstancePutWithNPEGuard(null);
+    } catch (NullPointerException npe) {
+      fail("Unexpected NPE");
+    }
+    try {
+      uninstantiatedInstancePutWithOtherGuard(null);
+      fail("Expected NullPointerException");
+    } catch (NullPointerException npe) {
+      System.out.println("Expected NPE");
+    }
+    try {
+      uninstantiatedInstanceInvoke(null);
+      fail("Expected NullPointerException");
+    } catch (NullPointerException npe) {
+      System.out.println("Expected NPE");
+    }
+    try {
+      nullReferenceInvoke();
+    } catch (NullPointerException npe) {
+      fail("Unexpected NPE");
+    }
+    try {
+      uninstantiatedInstancePut(null);
+      fail("Expected NullPointerException");
+    } catch (NullPointerException npe) {
+      System.out.println("Expected NPE");
+    }
+    try {
+      uninstantiatedInstanceGet(null);
+      fail("Expected NullPointerException");
+    } catch (NullPointerException npe) {
+      System.out.println("Expected NPE");
+    }
+  }
+}
+
+@RunWith(Parameterized.class)
+public class AlwaysThrowNullTest extends TestBase {
+  private static final String JAVA_OUTPUT = StringUtils.lines(
+      "Expected NPE",
+      "Expected NPE",
+      "Expected NPE",
+      "Expected NPE",
+      "Expected NPE",
+      "Expected NPE"
+  );
+  private static final Class<?> MAIN = AlwaysThrowNullTestClass.class;
+  private static final List<String> METHODS_WITH_NPE_GUARD = ImmutableList.of(
+      "uninstantiatedInstancePutWithNPEGuard",
+      "nullReferenceInvoke"
+  );
+  private static final List<String> METHODS_WITHOUT_GUARD = ImmutableList.of(
+      "uninstantiatedInstanceInvoke",
+      "uninstantiatedInstancePut",
+      "uninstantiatedInstanceGet"
+  );
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().build();
+  }
+
+  private final TestParameters parameters;
+
+  public AlwaysThrowNullTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testJvmOutput() throws Exception {
+    assumeTrue("Only run JVM reference once (for CF backend)", parameters.isCfRuntime());
+    testForJvm()
+        .addTestClasspath()
+        .run(parameters.getRuntime(), MAIN)
+        .assertSuccessWithOutput(JAVA_OUTPUT);
+  }
+
+  private void test(TestRunResult result, boolean hasLiveness) throws Exception {
+    CodeInspector codeInspector = result.inspector();
+    ClassSubject mainClass = codeInspector.clazz(MAIN);
+
+    int expectedThrow = hasLiveness ? 1 : 0;
+    for (String methodName : METHODS_WITH_NPE_GUARD) {
+      MethodSubject withNPEGuard = mainClass.uniqueMethodWithName(methodName);
+      assertThat(withNPEGuard, isPresent());
+      // catch handlers could be split, and thus not always 1, but some small positive numbers.
+      assertTrue(
+        Streams.stream(
+            withNPEGuard.iterateTryCatches(
+                t -> t.isCatching(NullPointerException.class.getName()))
+        ).count() > 0);
+      assertEquals(
+          expectedThrow,
+          Streams.stream(withNPEGuard.iterateInstructions(InstructionSubject::isThrow)).count());
+    }
+
+    int expectedHandler = hasLiveness ? 0 : 1;
+    MethodSubject withOtherGuard =
+        mainClass.uniqueMethodWithName("uninstantiatedInstancePutWithOtherGuard");
+    assertThat(withOtherGuard, isPresent());
+    assertEquals(expectedHandler, Streams.stream(withOtherGuard.iterateTryCatches()).count());
+
+    for (String methodName : METHODS_WITHOUT_GUARD) {
+      MethodSubject mtd = mainClass.uniqueMethodWithName(methodName);
+      assertThat(mtd, isPresent());
+      assertEquals(
+          hasLiveness,
+          Streams.stream(mtd.iterateInstructions(InstructionSubject::isInvoke)).count() == 0);
+      assertEquals(
+          expectedThrow,
+          Streams.stream(mtd.iterateInstructions(InstructionSubject::isThrow)).count());
+    }
+  }
+
+  @Test
+  public void testD8() throws Exception {
+    assumeTrue("Only run D8 for Dex backend", parameters.isDexRuntime());
+    D8TestRunResult result =
+        testForD8()
+            .release()
+            .addProgramClassesAndInnerClasses(MAIN)
+            .setMinApi(parameters.getRuntime())
+            .run(parameters.getRuntime(), MAIN)
+            .assertSuccessWithOutput(JAVA_OUTPUT);
+    test(result, false);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    R8TestRunResult result =
+        testForR8(parameters.getBackend())
+            .addProgramClassesAndInnerClasses(MAIN)
+            .enableMergeAnnotations()
+            .enableInliningAnnotations()
+            .enableMemberValuePropagationAnnotations()
+            .addKeepMainRule(MAIN)
+            .noMinification()
+            .setMinApi(parameters.getRuntime())
+            .run(parameters.getRuntime(), MAIN)
+            .assertSuccessWithOutput(JAVA_OUTPUT);
+    test(result, true);
+  }
+
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTest.java
index 3f3ccd2..26a3f4e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTest.java
@@ -64,7 +64,7 @@
       if (curr.isAssumeNonNull()) {
         // Make sure non-null is added to the right place.
         assertTrue(prev == null
-            || NonNullTracker.throwsOnNullInput(prev)
+            || prev.throwsOnNullInput()
             || (prev.isIf() && prev.asIf().isZeroTest())
             || !curr.getBlock().getPredecessors().contains(prev.getBlock()));
         // Make sure non-null is used or inserted for arguments.
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/ObjectsRequireNonNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/ObjectsRequireNonNullTest.java
index 9e22ade..df4598f 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/ObjectsRequireNonNullTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/ObjectsRequireNonNullTest.java
@@ -6,6 +6,7 @@
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
 import static org.junit.Assume.assumeTrue;
 
 import com.android.tools.r8.D8TestRunResult;
@@ -77,12 +78,14 @@
     unknownArg(instance);
     try {
       unknownArg(null);
+      fail("Expected NullPointerException");
     } catch (NullPointerException npe) {
       System.out.println("Expected NPE");
     }
 
     try {
       consumeUninitialized(null);
+      fail("Expected NullPointerException");
     } catch (NullPointerException npe) {
       System.out.println("Expected NPE");
     }
@@ -167,35 +170,38 @@
   @Test
   public void testD8() throws Exception {
     assumeTrue("Only run D8 for Dex backend", parameters.isDexRuntime());
-    D8TestRunResult result = testForD8()
-        .debug()
-        .addProgramClassesAndInnerClasses(MAIN)
-        .setMinApi(parameters.getRuntime())
-        .run(parameters.getRuntime(), MAIN)
-        .assertSuccessWithOutput(JAVA_OUTPUT);
+    D8TestRunResult result =
+        testForD8()
+            .debug()
+            .addProgramClassesAndInnerClasses(MAIN)
+            .setMinApi(parameters.getRuntime())
+            .run(parameters.getRuntime(), MAIN)
+            .assertSuccessWithOutput(JAVA_OUTPUT);
     test(result, 2, 1);
 
-    result = testForD8()
-        .release()
-        .addProgramClassesAndInnerClasses(MAIN)
-        .setMinApi(parameters.getRuntime())
-        .run(parameters.getRuntime(), MAIN)
-        .assertSuccessWithOutput(JAVA_OUTPUT);
+    result =
+        testForD8()
+            .release()
+            .addProgramClassesAndInnerClasses(MAIN)
+            .setMinApi(parameters.getRuntime())
+            .run(parameters.getRuntime(), MAIN)
+            .assertSuccessWithOutput(JAVA_OUTPUT);
     test(result, 0, 1);
   }
 
   @Test
   public void testR8() throws Exception {
     assumeTrue("CF disables move result optimization", parameters.isDexRuntime());
-    R8TestRunResult result = testForR8(parameters.getBackend())
-        .addProgramClassesAndInnerClasses(MAIN)
-        .enableInliningAnnotations()
-        .enableMemberValuePropagationAnnotations()
-        .addKeepMainRule(MAIN)
-        .noMinification()
-        .setMinApi(parameters.getRuntime())
-        .run(parameters.getRuntime(), MAIN)
-        .assertSuccessWithOutput(JAVA_OUTPUT);
+    R8TestRunResult result =
+        testForR8(parameters.getBackend())
+            .addProgramClassesAndInnerClasses(MAIN)
+            .enableInliningAnnotations()
+            .enableMemberValuePropagationAnnotations()
+            .addKeepMainRule(MAIN)
+            .noMinification()
+            .setMinApi(parameters.getRuntime())
+            .run(parameters.getRuntime(), MAIN)
+            .assertSuccessWithOutput(JAVA_OUTPUT);
     test(result, 0, 0);
   }
 }
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/instanceofremoval/UninstantiatedAnnotationTypeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/instanceofremoval/UninstantiatedAnnotationTypeTest.java
index 7f61c30..98f28ba 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/instanceofremoval/UninstantiatedAnnotationTypeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/instanceofremoval/UninstantiatedAnnotationTypeTest.java
@@ -5,12 +5,13 @@
 package com.android.tools.r8.ir.optimize.instanceofremoval;
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
 
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.TestBase;
-import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.InstructionSubject;
@@ -58,15 +59,15 @@
     }
   }
 
-  @Parameters(name = "Backend: {0}")
-  public static Backend[] data() {
-    return ToolHelper.getBackends();
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().build();
   }
 
-  private final Backend backend;
+  private final TestParameters parameters;
 
-  public UninstantiatedAnnotationTypeTest(Backend backend) {
-    this.backend = backend;
+  public UninstantiatedAnnotationTypeTest(TestParameters parameters) {
+    this.parameters = parameters;
   }
 
   @Test
@@ -76,12 +77,13 @@
     testForJvm().addTestClasspath().run(TestClass.class).assertSuccessWithOutput(expected);
 
     CodeInspector inspector =
-        testForR8(backend)
+        testForR8(parameters.getBackend())
             .addInnerClasses(UninstantiatedAnnotationTypeTest.class)
             .addKeepMainRule(TestClass.class)
             .addKeepRules("-keepattributes RuntimeVisibleAnnotations")
             .enableInliningAnnotations()
-            .run(TestClass.class)
+            .setMinApi(parameters.getRuntime())
+            .run(parameters.getRuntime(), TestClass.class)
             .assertSuccessWithOutput(expected)
             .inspector();
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/instanceofremoval/UninstantiatedLibraryTypeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/instanceofremoval/UninstantiatedLibraryTypeTest.java
index cff27b4..62db9fc 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/instanceofremoval/UninstantiatedLibraryTypeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/instanceofremoval/UninstantiatedLibraryTypeTest.java
@@ -5,12 +5,13 @@
 package com.android.tools.r8.ir.optimize.instanceofremoval;
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
 
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.TestBase;
-import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.InstructionSubject;
@@ -59,15 +60,15 @@
     }
   }
 
-  @Parameters(name = "Backend: {0}")
-  public static Backend[] data() {
-    return ToolHelper.getBackends();
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().build();
   }
 
-  private final Backend backend;
+  private final TestParameters parameters;
 
-  public UninstantiatedLibraryTypeTest(Backend backend) {
-    this.backend = backend;
+  public UninstantiatedLibraryTypeTest(TestParameters parameters) {
+    this.parameters = parameters;
   }
 
   @Test
@@ -77,11 +78,12 @@
     testForJvm().addTestClasspath().run(TestClass.class).assertSuccessWithOutput(expected);
 
     CodeInspector inspector =
-        testForR8(backend)
+        testForR8(parameters.getBackend())
             .addInnerClasses(UninstantiatedLibraryTypeTest.class)
             .addKeepMainRule(TestClass.class)
             .enableInliningAnnotations()
-            .run(TestClass.class)
+            .setMinApi(parameters.getRuntime())
+            .run(parameters.getRuntime(), TestClass.class)
             .assertSuccessWithOutput(expected)
             .inspector();
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/instanceofremoval/UninstantiatedProgramTypeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/instanceofremoval/UninstantiatedProgramTypeTest.java
index df2739a..471405d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/instanceofremoval/UninstantiatedProgramTypeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/instanceofremoval/UninstantiatedProgramTypeTest.java
@@ -5,13 +5,14 @@
 package com.android.tools.r8.ir.optimize.instanceofremoval;
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.IsNot.not;
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
 
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.TestBase;
-import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.InstructionSubject;
@@ -58,15 +59,15 @@
     }
   }
 
-  @Parameters(name = "Backend: {0}")
-  public static Backend[] data() {
-    return ToolHelper.getBackends();
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().build();
   }
 
-  private final Backend backend;
+  private final TestParameters parameters;
 
-  public UninstantiatedProgramTypeTest(Backend backend) {
-    this.backend = backend;
+  public UninstantiatedProgramTypeTest(TestParameters parameters) {
+    this.parameters = parameters;
   }
 
   @Test
@@ -76,11 +77,12 @@
     testForJvm().addTestClasspath().run(TestClass.class).assertSuccessWithOutput(expected);
 
     CodeInspector inspector =
-        testForR8(backend)
+        testForR8(parameters.getBackend())
             .addInnerClasses(UninstantiatedProgramTypeTest.class)
             .addKeepMainRule(TestClass.class)
             .enableInliningAnnotations()
-            .run(TestClass.class)
+            .setMinApi(parameters.getRuntime())
+            .run(parameters.getRuntime(), TestClass.class)
             .assertSuccessWithOutput(expected)
             .inspector();
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizerTest.java
index b5071f4..a676b5d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/staticizer/ClassStaticizerTest.java
@@ -6,17 +6,17 @@
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeTrue;
 
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.TestRunResult;
-import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.code.Instruction;
 import com.android.tools.r8.code.InvokeDirect;
 import com.android.tools.r8.code.InvokeStatic;
@@ -60,20 +60,20 @@
 
 @RunWith(Parameterized.class)
 public class ClassStaticizerTest extends TestBase {
-  private Backend backend;
+  private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "Backend: {0}")
-  public static Backend[] data() {
-    return ToolHelper.getBackends();
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    // TODO(b/112831361): support for class staticizer in CF backend.
+    return getTestParameters().withDexRuntimes().build();
   }
 
-  public ClassStaticizerTest(Backend backend) {
-    this.backend = backend;
+  public ClassStaticizerTest(TestParameters parameters) {
+    this.parameters = parameters;
   }
 
   @Test
   public void testTrivial() throws Exception {
-    assumeTrue("b/112831361", backend == Backend.DEX);
     Class<?> main = TrivialTestClass.class;
     Class<?>[] classes = {
         NeverInline.class,
@@ -86,17 +86,18 @@
         SimpleWithPhi.Companion.class
     };
     String javaOutput = runOnJava(main);
-    TestRunResult result = testForR8(backend)
-        .addProgramClasses(classes)
-        .enableProguardTestOptions()
-        .enableInliningAnnotations()
-        .addKeepMainRule(main)
-        .noMinification()
-        .addKeepRules("-allowaccessmodification")
-        .addKeepRules("-keepattributes InnerClasses,EnclosingMethod")
-        .addOptionsModification(this::configure)
-        .run(main)
-        .assertSuccessWithOutput(javaOutput);
+    TestRunResult result =
+        testForR8(parameters.getBackend())
+            .addProgramClasses(classes)
+            .enableInliningAnnotations()
+            .addKeepMainRule(main)
+            .noMinification()
+            .addKeepRules("-allowaccessmodification")
+            .addKeepRules("-keepattributes InnerClasses,EnclosingMethod")
+            .addOptionsModification(this::configure)
+            .setMinApi(parameters.getRuntime())
+            .run(parameters.getRuntime(), main)
+            .assertSuccessWithOutput(javaOutput);
 
     CodeInspector inspector = result.inspector();
     ClassSubject clazz = inspector.clazz(main);
@@ -155,7 +156,6 @@
 
   @Test
   public void testMoveToHost_fieldOnly() throws Exception {
-    assumeTrue("b/112831361", backend == Backend.DEX);
     Class<?> main = MoveToHostFieldOnlyTestClass.class;
     Class<?>[] classes = {
         NeverInline.class,
@@ -163,15 +163,16 @@
         HostOkFieldOnly.class,
         CandidateOkFieldOnly.class
     };
-    TestRunResult result = testForR8(backend)
-        .addProgramClasses(classes)
-        .enableProguardTestOptions()
-        .enableInliningAnnotations()
-        .addKeepMainRule(main)
-        .noMinification()
-        .addKeepRules("-allowaccessmodification")
-        .addOptionsModification(this::configure)
-        .run(main);
+    TestRunResult result =
+        testForR8(parameters.getBackend())
+            .addProgramClasses(classes)
+            .enableInliningAnnotations()
+            .addKeepMainRule(main)
+            .noMinification()
+            .addKeepRules("-allowaccessmodification")
+            .addOptionsModification(this::configure)
+            .setMinApi(parameters.getRuntime())
+            .run(parameters.getRuntime(), main);
 
     CodeInspector inspector = result.inspector();
     ClassSubject clazz = inspector.clazz(main);
@@ -185,7 +186,6 @@
 
   @Test
   public void testMoveToHost() throws Exception {
-    assumeTrue("b/112831361", backend == Backend.DEX);
     Class<?> main = MoveToHostTestClass.class;
     Class<?>[] classes = {
         NeverInline.class,
@@ -200,16 +200,17 @@
         CandidateConflictField.class
     };
     String javaOutput = runOnJava(main);
-    TestRunResult result = testForR8(backend)
-        .addProgramClasses(classes)
-        .enableProguardTestOptions()
-        .enableInliningAnnotations()
-        .addKeepMainRule(main)
-        .noMinification()
-        .addKeepRules("-allowaccessmodification")
-        .addOptionsModification(this::configure)
-        .run(main)
-        .assertSuccessWithOutput(javaOutput);
+    TestRunResult result =
+        testForR8(parameters.getBackend())
+            .addProgramClasses(classes)
+            .enableInliningAnnotations()
+            .addKeepMainRule(main)
+            .noMinification()
+            .addKeepRules("-allowaccessmodification")
+            .addOptionsModification(this::configure)
+            .setMinApi(parameters.getRuntime())
+            .run(parameters.getRuntime(), main)
+            .assertSuccessWithOutput(javaOutput);
 
     CodeInspector inspector = result.inspector();
     ClassSubject clazz = inspector.clazz(main);
@@ -313,28 +314,28 @@
 
   private void configure(InternalOptions options) {
     options.enableClassInlining = false;
+    options.enableUninstantiatedTypeOptimization = false;
   }
 
-
   @Test
   public void dualInlinedMethodRewritten() throws Exception {
-    assumeTrue("b/112831361", backend == Backend.DEX);
     Class<?> main = DualCallTest.class;
     Class<?>[] classes = {
         DualCallTest.class,
         Candidate.class
     };
     String javaOutput = runOnJava(main);
-    TestRunResult result = testForR8(backend)
-        .addProgramClasses(classes)
-        .enableProguardTestOptions()
-        .enableInliningAnnotations()
-        .addKeepMainRule(main)
-        .noMinification()
-        .addKeepRules("-allowaccessmodification")
-        .addOptionsModification(this::configure)
-        .run(main)
-        .assertSuccessWithOutput(javaOutput);
+    TestRunResult result =
+        testForR8(parameters.getBackend())
+            .addProgramClasses(classes)
+            .enableInliningAnnotations()
+            .addKeepMainRule(main)
+            .noMinification()
+            .addKeepRules("-allowaccessmodification")
+            .addOptionsModification(this::configure)
+            .setMinApi(parameters.getRuntime())
+            .run(parameters.getRuntime(), main)
+            .assertSuccessWithOutput(javaOutput);
 
     CodeInspector inspector = result.inspector();
     ClassSubject clazz = inspector.clazz(main);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/string/StringValueOfTest.java b/src/test/java/com/android/tools/r8/ir/optimize/string/StringValueOfTest.java
index 4d8dddb..91ffa3d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/string/StringValueOfTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/string/StringValueOfTest.java
@@ -99,7 +99,11 @@
     } catch (NullPointerException npe) {
       fail("Not expected: " + npe);
     }
-    System.out.println(consumeUninitialized(null));
+    try {
+      System.out.println(consumeUninitialized(null));
+    } catch (NullPointerException npe) {
+      fail("Not expected: " + npe);
+    }
 
     // No matter what we pass, that function will return null.
     // But, we're not sure about it, hence not optimizing String#valueOf.
@@ -129,7 +133,6 @@
   private static final Class<?> MAIN = StringValueOfTestMain.class;
 
   private static final String STRING_DESCRIPTOR = "Ljava/lang/String;";
-  private static final String STRING_TYPE = "java.lang.String";
 
   @Parameterized.Parameters(name = "{0}")
   public static TestParametersCollection data() {
diff --git a/src/test/java/com/android/tools/r8/naming/EnumMinificationKotlinTest.java b/src/test/java/com/android/tools/r8/naming/EnumMinificationKotlinTest.java
index cd1520e..d56ae8e 100644
--- a/src/test/java/com/android/tools/r8/naming/EnumMinificationKotlinTest.java
+++ b/src/test/java/com/android/tools/r8/naming/EnumMinificationKotlinTest.java
@@ -4,11 +4,11 @@
 package com.android.tools.r8.naming;
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
 
 import com.android.tools.r8.KotlinTestBase;
-import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.utils.BooleanUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -27,30 +27,35 @@
   private static final String MAIN_CLASS_NAME = "minify_enum.MainKt";
   private static final String ENUM_CLASS_NAME = "minify_enum.MinifyEnum";
 
-  private final Backend backend;
+  private final TestParameters parameters;
   private final boolean minify;
 
-  @Parameterized.Parameters(name = "Backend: {0} target: {1} minify: {2}")
+  @Parameterized.Parameters(name = "{0} target: {1} minify: {2}")
   public static Collection<Object[]> data() {
-    return buildParameters(ToolHelper.getBackends(), KotlinTargetVersion.values(), BooleanUtils.values());
+    return buildParameters(
+        getTestParameters().withAllRuntimes().build(),
+        KotlinTargetVersion.values(),
+        BooleanUtils.values());
   }
 
   public EnumMinificationKotlinTest(
-      Backend backend, KotlinTargetVersion targetVersion, boolean minify) {
+      TestParameters parameters, KotlinTargetVersion targetVersion, boolean minify) {
     super(targetVersion);
-    this.backend = backend;
+    this.parameters = parameters;
     this.minify = minify;
   }
 
   @Test
   public void b121221542() throws Exception {
-    CodeInspector inspector = testForR8(backend)
-        .addProgramFiles(getKotlinJarFile(FOLDER))
-        .addProgramFiles(getJavaJarFile(FOLDER))
-        .addKeepMainRule(MAIN_CLASS_NAME)
-        .minification(minify)
-        .run(MAIN_CLASS_NAME)
-        .inspector();
+    CodeInspector inspector =
+        testForR8(parameters.getBackend())
+            .addProgramFiles(getKotlinJarFile(FOLDER))
+            .addProgramFiles(getJavaJarFile(FOLDER))
+            .addKeepMainRule(MAIN_CLASS_NAME)
+            .minification(minify)
+            .setMinApi(parameters.getRuntime())
+            .run(parameters.getRuntime(), MAIN_CLASS_NAME)
+            .inspector();
     ClassSubject enumClass = inspector.clazz(ENUM_CLASS_NAME);
     assertThat(enumClass, isPresent());
     assertEquals(minify, enumClass.isRenamed());
diff --git a/src/test/java/com/android/tools/r8/shaking/FieldReadsJasminTest.java b/src/test/java/com/android/tools/r8/shaking/FieldReadsJasminTest.java
index 20b2850..f22cc41 100644
--- a/src/test/java/com/android/tools/r8/shaking/FieldReadsJasminTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/FieldReadsJasminTest.java
@@ -5,13 +5,14 @@
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
-import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.jasmin.JasminBuilder;
 import com.android.tools.r8.jasmin.JasminBuilder.ClassBuilder;
 import com.android.tools.r8.jasmin.JasminTestBase;
@@ -30,15 +31,15 @@
 public class FieldReadsJasminTest extends JasminTestBase {
   private static final String CLS = "Empty";
   private static final String MAIN = "Main";
-  private final Backend backend;
+  private final TestParameters parameters;
 
-  @Parameterized.Parameters(name = "Backend: {0}")
-  public static Object[] data() {
-    return ToolHelper.getBackends();
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().build();
   }
 
-  public FieldReadsJasminTest(Backend backend) {
-    this.backend = backend;
+  public FieldReadsJasminTest(TestParameters parameters) {
+    this.parameters = parameters;
   }
 
   @Test
@@ -79,9 +80,10 @@
   }
 
   private void ensureNoFields(JasminBuilder app, ClassBuilder clazz) throws Exception {
-    testForR8(backend)
+    testForR8(parameters.getBackend())
         .addProgramClassFileData(app.buildClasses())
         .addKeepRules("-keep class * { <methods>; }")
+        .setMinApi(parameters.getRuntime())
         .compile()
         .inspect(inspector -> {
           ClassSubject classSubject = inspector.clazz(clazz.name);
@@ -129,9 +131,10 @@
       ClassBuilder fieldHolder,
       String fieldName)
       throws Exception {
-    testForR8(backend)
+    testForR8(parameters.getBackend())
         .addProgramClassFileData(app.buildClasses())
         .addKeepRules("-keep class * { <methods>; }")
+        .setMinApi(parameters.getRuntime())
         .compile()
         .inspect(inspector -> {
           FieldSubject fld = inspector.clazz(fieldHolder.name).uniqueFieldWithName(fieldName);
@@ -264,9 +267,10 @@
       ClassBuilder fieldHolder,
       String fieldName)
       throws Exception {
-    testForR8(backend)
+    testForR8(parameters.getBackend())
         .addProgramClassFileData(app.buildClasses())
         .addKeepRules("-keep class * { <methods>; }")
+        .setMinApi(parameters.getRuntime())
         .compile()
         .inspect(inspector -> {
           FieldSubject fld = inspector.clazz(fieldHolder.name).uniqueFieldWithName(fieldName);
diff --git a/src/test/java/com/android/tools/r8/shaking/InvalidTypesTest.java b/src/test/java/com/android/tools/r8/shaking/InvalidTypesTest.java
index 032bd05..64dbadf 100644
--- a/src/test/java/com/android/tools/r8/shaking/InvalidTypesTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/InvalidTypesTest.java
@@ -13,6 +13,7 @@
 import com.android.tools.r8.DXTestRunResult;
 import com.android.tools.r8.ProguardTestRunResult;
 import com.android.tools.r8.R8TestRunResult;
+import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestRunResult;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.ToolHelper.DexVm.Version;
@@ -64,19 +65,20 @@
     }
   }
 
-  private final Backend backend;
+  private final TestParameters parameters;
   private final Mode mode;
   private final boolean useInterface;
 
-  public InvalidTypesTest(Backend backend, Mode mode, boolean useInterface) {
-    this.backend = backend;
+  public InvalidTypesTest(TestParameters parameters, Mode mode, boolean useInterface) {
+    this.parameters = parameters;
     this.mode = mode;
     this.useInterface = useInterface;
   }
 
-  @Parameters(name = "Backend: {0}, mode: {1}, use interface: {2}")
+  @Parameters(name = "{0}, mode: {1}, use interface: {2}")
   public static Collection<Object[]> parameters() {
-    return buildParameters(ToolHelper.getBackends(), Mode.values(), BooleanUtils.values());
+    return buildParameters(
+        getTestParameters().withAllRuntimes().build(), Mode.values(), BooleanUtils.values());
   }
 
   @Test
@@ -167,7 +169,7 @@
     Path inputJar = temp.getRoot().toPath().resolve("input.jar");
     jasminBuilder.writeJar(inputJar);
 
-    if (backend == Backend.CF) {
+    if (parameters.isCfRuntime()) {
       TestRunResult<?> jvmResult = testForJvm().addClasspath(inputJar).run(mainClass.name);
       checkTestRunResult(jvmResult, Compiler.JAVAC);
 
@@ -179,7 +181,7 @@
               .run(mainClass.name);
       checkTestRunResult(proguardResult, Compiler.PROGUARD);
     } else {
-      assert backend == Backend.DEX;
+      assert parameters.isDexRuntime();
 
       DXTestRunResult dxResult = testForDX().addProgramFiles(inputJar).run(mainClass.name);
       checkTestRunResult(dxResult, Compiler.DX);
@@ -189,7 +191,7 @@
     }
 
     R8TestRunResult r8Result =
-        testForR8(backend)
+        testForR8(parameters.getBackend())
             .addProgramFiles(inputJar)
             .addKeepMainRule(mainClass.name)
             .addKeepRules(
@@ -202,7 +204,8 @@
                   }
                 })
             .enableInliningAnnotations()
-            .run(mainClass.name);
+            .setMinApi(parameters.getRuntime())
+            .run(parameters.getRuntime(), mainClass.name);
     checkTestRunResult(r8Result, Compiler.R8);
   }
 
@@ -304,13 +307,13 @@
   }
 
   private Matcher<String> getMatcherForExpectedError() {
-    if (backend == Backend.CF) {
+    if (parameters.isCfRuntime()) {
       return allOf(
           containsString("java.lang.VerifyError"),
           containsString("Bad type in putfield/putstatic"));
     }
 
-    assert backend == Backend.DEX;
+    assert parameters.isDexRuntime();
     return allOf(
         containsString("java.lang.VerifyError"),
         anyOf(