diff --git a/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionIterator.java b/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionIterator.java
index 81e79e6..09bc9cb 100644
--- a/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionIterator.java
+++ b/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionIterator.java
@@ -364,7 +364,7 @@
       castInstruction.setPosition(invoke.getPosition());
 
       // Splice in the check cast operation.
-      if (entryBlock.canThrow() || invokeBlock.hasCatchHandlers()) {
+      if (entryBlock.canThrow()) {
         // Since the cast-instruction may also fail we need to create a new block for the cast.
         //
         // Note that the downcast of the receiver is made at the call site, so we need to copy the
@@ -410,13 +410,7 @@
 
     BasicBlock inlineExit = null;
     ImmutableList<BasicBlock> normalExits = inlinee.computeNormalExitBlocks();
-    if (normalExits.isEmpty()) {
-      assert inlineeCanThrow;
-      // TODO(sgjesse): Remove this restriction (see b/64432527).
-      assert !invokeBlock.hasCatchHandlers();
-      blocksToRemove.addAll(
-          invokePredecessor.unlink(invokeBlock, new DominatorTree(code)));
-    } else {
+    if (!normalExits.isEmpty()) {
       // Ensure and locate the single return instruction of the inlinee.
       InstructionListIterator inlineeIterator = ensureSingleReturnInstruction(inlinee, normalExits);
 
@@ -475,6 +469,25 @@
       appendCatchHandlers(code, invokeBlock, inlinee, blocksIterator);
     }
 
+    // If there are no normal exists, then unlink the invoke block and all the blocks that it
+    // dominates. This must be done after the catch handlers have been appended to the inlinee,
+    // since the catch handlers are dominated by the inline block until then (meaning that the
+    // catch handlers would otherwise be removed although they are not actually dead).
+    if (normalExits.isEmpty()) {
+      assert inlineeCanThrow;
+      blocksToRemove.addAll(invokePredecessor.unlink(invokeBlock, new DominatorTree(code)));
+    }
+
+    // Position the iterator after the invoke block.
+    blocksIterator.next();
+    assert IteratorUtils.peekPrevious(blocksIterator) == invokeBlock;
+
+    // Check that the successor of the invoke block is still to be processed,
+    final BasicBlock finalInvokeSuccessor = invokeSuccessor;
+    assert invokeSuccessor == invokeBlock
+        || IteratorUtils.anyRemainingMatch(
+            blocksIterator, remaining -> remaining == finalInvokeSuccessor);
+
     return invokeSuccessor;
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/CfSourceCode.java b/src/main/java/com/android/tools/r8/ir/conversion/CfSourceCode.java
index 5f62c6c..8e91a62 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/CfSourceCode.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/CfSourceCode.java
@@ -192,8 +192,6 @@
   private boolean inPrelude;
   private Int2ObjectMap<DebugLocalInfo> incomingLocals;
   private Int2ObjectMap<DebugLocalInfo> outgoingLocals;
-  private Int2ReferenceMap<Int2ObjectMap<DebugLocalInfo>> definitelyLiveIncomingLocals =
-      new Int2ReferenceOpenHashMap<>();
   private Int2ReferenceMap<CfState.Snapshot> incomingState = new Int2ReferenceOpenHashMap<>();
   private final CanonicalPositions canonicalPositions;
 
@@ -371,38 +369,21 @@
     if (predecessorOffset == IRBuilder.INITIAL_BLOCK_OFFSET) {
       return;
     }
-    if (currentInstructionIndex != predecessorOffset) {
-      // If transfer is not still in the same block, then update the state to that of the successor.
-      // The builder's lookup of local variables relies on this state for starting locals.
-      currentInstructionIndex = successorOffset;
-      state.reset(incomingState.get(currentInstructionIndex), false);
-      setLocalVariableLists();
-      // The transfer has not yet taken place, so the current position is that of the predecessor.
-      int positionOffset = predecessorOffset;
-      List<CfInstruction> instructions = code.getInstructions();
-      CfInstruction instruction = instructions.get(positionOffset);
-      while (0 < positionOffset && !(instruction instanceof CfPosition)) {
-        instruction = instructions.get(--positionOffset);
-      }
-      if (instruction instanceof CfPosition) {
-        CfPosition position = (CfPosition) instruction;
-        state.setPosition(getCanonicalPosition(position.getPosition()));
-      } else {
-        state.setPosition(canonicalPositions.getPreamblePosition());
-      }
-    }
+    // The transfer has not yet taken place, so the current position is that of the predecessor.
+    state.setPosition(getCanonicalDebugPositionAtOffset(predecessorOffset));
+
     // Manually compute the local variable change for the block transfer.
-    LocalVariableList atSource = getLocalVariables(predecessorOffset);
-    LocalVariableList atTarget = getLocalVariables(successorOffset);
+    Int2ObjectMap<DebugLocalInfo> atSource = getLocalVariables(predecessorOffset).locals;
+    Int2ObjectMap<DebugLocalInfo> atTarget = getLocalVariables(successorOffset).locals;
     if (!isExceptional) {
-      for (Entry<DebugLocalInfo> entry : atSource.locals.int2ObjectEntrySet()) {
-        if (atTarget.locals.get(entry.getIntKey()) != entry.getValue()) {
+      for (Entry<DebugLocalInfo> entry : atSource.int2ObjectEntrySet()) {
+        if (atTarget.get(entry.getIntKey()) != entry.getValue()) {
           builder.addDebugLocalEnd(entry.getIntKey(), entry.getValue());
         }
       }
     }
-    for (Entry<DebugLocalInfo> entry : atTarget.locals.int2ObjectEntrySet()) {
-      if (atSource.locals.get(entry.getIntKey()) != entry.getValue()) {
+    for (Entry<DebugLocalInfo> entry : atTarget.int2ObjectEntrySet()) {
+      if (atSource.get(entry.getIntKey()) != entry.getValue()) {
         builder.addDebugLocalStart(entry.getIntKey(), entry.getValue());
       }
     }
@@ -562,33 +543,15 @@
 
   private void setLocalVariableLists() {
     incomingLocals = getLocalVariables(currentInstructionIndex).locals;
-    CfInstruction currentInstruction = code.getInstructions().get(currentInstructionIndex);
     if (inPrelude) {
       outgoingLocals = incomingLocals;
       return;
     }
-    if (currentInstruction.isReturn() || currentInstruction instanceof CfThrow) {
-      outgoingLocals = emptyMap();
-      return;
-    }
-    if (isControlFlow(currentInstruction)) {
-      // We need to read all locals that are not live on all successors to ensure liveness.
-      // Determine outgoingLocals as the intersection of all successors' locals.
-      outgoingLocals = null;
-      int[] targets = getTargets(currentInstructionIndex);
-      for (int target : targets) {
-        Int2ObjectMap<DebugLocalInfo> locals = getLocalVariables(target).locals;
-        outgoingLocals = intersectMaps(outgoingLocals, locals);
-      }
-      assert outgoingLocals != null;
-      // Pass outgoingLocals to all successors.
-      for (int target : targets) {
-        Int2ObjectMap<DebugLocalInfo> existing = definitelyLiveIncomingLocals.get(target);
-        definitelyLiveIncomingLocals.put(target, intersectMaps(existing, outgoingLocals));
-      }
-    } else {
-      outgoingLocals = getLocalVariables(currentInstructionIndex + 1).locals;
-    }
+    CfInstruction currentInstruction = code.getInstructions().get(currentInstructionIndex);
+    outgoingLocals =
+        !isControlFlow(currentInstruction)
+            ? getLocalVariables(currentInstructionIndex + 1).locals
+            : emptyMap();
   }
 
   private boolean localsChanged() {
@@ -613,27 +576,6 @@
     }
   }
 
-  private Int2ObjectMap<DebugLocalInfo> intersectMaps(
-      Int2ObjectMap<DebugLocalInfo> existing, Int2ObjectMap<DebugLocalInfo> update) {
-    assert update != null;
-    if (existing == null) {
-      return update;
-    }
-    if (existing.size() > update.size()) {
-      return intersectMaps(update, existing);
-    }
-    if (existing.equals(update)) {
-      return existing;
-    }
-    Int2ObjectOpenHashMap<DebugLocalInfo> result = new Int2ObjectOpenHashMap<>();
-    for (Entry<DebugLocalInfo> local : existing.int2ObjectEntrySet()) {
-      if (local.getValue().equals(update.get(local.getIntKey()))) {
-        result.put(local.getIntKey(), local.getValue());
-      }
-    }
-    return result;
-  }
-
   private boolean isControlFlow(CfInstruction currentInstruction) {
     return currentInstruction.isReturn()
         || currentInstruction.getTarget() != null
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java b/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
index 5c4d581..8fe972b 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
@@ -706,14 +706,6 @@
     addInstruction(new Argument(value));
   }
 
-  private void addDebugLocalWrite(ValueType type, int dest, Value in) {
-    assert options.debug;
-    Value out = writeRegister(dest, type, ThrowingInfo.NO_THROW);
-    DebugLocalWrite write = new DebugLocalWrite(out, in);
-    assert !write.instructionTypeCanThrow();
-    addInstruction(write);
-  }
-
   private Value getIncomingLocalValue(int register, DebugLocalInfo local) {
     assert options.debug;
     assert local != null;
@@ -729,26 +721,26 @@
   }
 
   public void addDebugLocalStart(int register, DebugLocalInfo local) {
+    assert local != null;
     if (!options.debug) {
       return;
     }
-    assert local != null;
-    assert local == getOutgoingLocal(register) :
-        "local-start mismatch: " + local + " != " + getOutgoingLocal(register)
-            + " at " + currentInstructionOffset
-            + " for source\n" + source.toString();
-    // TODO(b/111251032): Here we lookup a value with type based on debug info. That's just wrong!
-    ValueType valueType = ValueType.fromDexType(local.type);
-    Value incomingValue = readRegisterIgnoreLocal(register, valueType, local);
     // If the local was not introduced by the previous instruction, start it here.
+    Value incomingValue = getIncomingLocalValue(register, local);
     if (incomingValue.getLocalInfo() != local
         || currentBlock.isEmpty()
         || currentBlock.getInstructions().getLast().outValue() != incomingValue) {
-      addDebugLocalWrite(ValueType.fromDexType(local.type), register, incomingValue);
+      // Note that the write register must not lookup outgoing local information and the local is
+      // never considered clobbered by a start (if the in value has local info it must have been
+      // marked ended elsewhere).
+      Value out = writeRegister(register, incomingValue.outType(), ThrowingInfo.NO_THROW, local);
+      DebugLocalWrite write = new DebugLocalWrite(out, incomingValue);
+      addInstruction(write);
     }
   }
 
   public void addDebugLocalEnd(int register, DebugLocalInfo local) {
+    assert local != null;
     if (!options.debug) {
       return;
     }
@@ -951,7 +943,8 @@
       // If the move is writing to a different local we must construct a new value.
       DebugLocalInfo destLocal = getOutgoingLocal(dest);
       if (destLocal != null && destLocal != in.getLocalInfo()) {
-        addDebugLocalWrite(type, dest, in);
+        Value out = writeRegister(dest, type, ThrowingInfo.NO_THROW);
+        addInstruction(new DebugLocalWrite(out, in));
         return;
       }
     }
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/JarSourceCode.java b/src/main/java/com/android/tools/r8/ir/conversion/JarSourceCode.java
index e528a90..1039817 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/JarSourceCode.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/JarSourceCode.java
@@ -476,6 +476,7 @@
         || successorOffset == EXCEPTIONAL_SYNC_EXIT_OFFSET) {
       return;
     }
+    // The transfer has not yet taken place, so the current position is that of the predecessor.
     currentPosition = getCanonicalDebugPositionAtOffset(predecessorOffset);
 
     LocalChangeAtOffset localChange = state.getLocalChange(predecessorOffset, successorOffset);
@@ -484,12 +485,8 @@
         builder.addDebugLocalEnd(toClose.slot.register, toClose.info);
       }
     }
-    List<Local> localsToOpen = localChange.getLocalsToOpen();
-    if (!localsToOpen.isEmpty()) {
-      state.restoreState(successorOffset);
-      for (Local toOpen : localsToOpen) {
-        builder.addDebugLocalStart(toOpen.slot.register, toOpen.info);
-      }
+    for (Local toOpen : localChange.getLocalsToOpen()) {
+      builder.addDebugLocalStart(toOpen.slot.register, toOpen.info);
     }
   }
 
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 998ebe9..823de39 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
@@ -20,6 +20,7 @@
 import com.android.tools.r8.ir.optimize.Inliner.Reason;
 import com.android.tools.r8.logging.Log;
 import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.IteratorUtils;
 import java.util.BitSet;
 import java.util.List;
 import java.util.ListIterator;
@@ -366,21 +367,29 @@
   }
 
   @Override
-  public ListIterator<BasicBlock> updateTypeInformationIfNeeded(IRCode inlinee,
-      ListIterator<BasicBlock> blockIterator, BasicBlock block, BasicBlock invokeSuccessor) {
+  public void updateTypeInformationIfNeeded(
+      IRCode inlinee, ListIterator<BasicBlock> blockIterator, BasicBlock block) {
     if (inliner.options.enableNonNullTracking) {
-      // Move the cursor back to where the inlinee blocks are added.
-      blockIterator = code.blocks.listIterator(code.blocks.indexOf(block));
+      BasicBlock state = IteratorUtils.peekNext(blockIterator);
+      // Move the cursor back to where the first inlinee block was added.
+      while (blockIterator.hasPrevious() && blockIterator.previous() != block) {
+        // Do nothing.
+      }
+      assert IteratorUtils.peekNext(blockIterator) == block;
+
       // Kick off the tracker to add non-null IRs only to the inlinee blocks.
-      new NonNullTracker()
-          .addNonNullInPart(code, blockIterator, inlinee.blocks::contains);
-      // Move the cursor forward to where the inlinee blocks end.
-      blockIterator = code.blocks.listIterator(code.blocks.indexOf(invokeSuccessor));
+      new NonNullTracker().addNonNullInPart(code, blockIterator, inlinee.blocks::contains);
+      assert !blockIterator.hasNext();
+
+      // Restore the old state of the iterator.
+      while (blockIterator.hasPrevious() && blockIterator.previous() != state) {
+        // Do nothing.
+      }
+      assert IteratorUtils.peekNext(blockIterator) == state;
     }
     // Update type env for inlined blocks.
     typeEnvironment.analyzeBlocks(inlinee.topologicallySortedBlocks());
     // TODO(b/69964136): need a test where refined env in inlinee affects the caller.
-    return blockIterator;
   }
 
   @Override
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 85f7a39..07100fa 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
@@ -70,10 +70,8 @@
   }
 
   @Override
-  public ListIterator<BasicBlock> updateTypeInformationIfNeeded(IRCode inlinee,
-      ListIterator<BasicBlock> blockIterator, BasicBlock block, BasicBlock invokeSuccessor) {
-    return blockIterator;
-  }
+  public void updateTypeInformationIfNeeded(
+      IRCode inlinee, ListIterator<BasicBlock> blockIterator, BasicBlock block) {}
 
   @Override
   public boolean exceededAllowance() {
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 106d537..491269e 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
@@ -591,11 +591,6 @@
                 result.buildInliningIR(code.valueNumberGenerator,
                     appInfo, converter.getGraphLense(), options, invokePosition);
             if (inlinee != null) {
-              // TODO(64432527): Get rid of this additional check by improved inlining.
-              if (block.hasCatchHandlers() && inlinee.computeNormalExitBlocks().isEmpty()) {
-                continue;
-              }
-
               // If this code did not go through the full pipeline, apply inlining to make sure
               // that force inline targets get processed.
               strategy.ensureMethodProcessed(target, inlinee);
@@ -611,10 +606,8 @@
               iterator.previous();
               strategy.markInlined(inlinee);
               if (!strategy.exceededAllowance() || result.ignoreInstructionBudget()) {
-                BasicBlock invokeSuccessor =
-                    iterator.inlineInvoke(code, inlinee, blockIterator, blocksToRemove, downcast);
-                blockIterator = strategy.
-                    updateTypeInformationIfNeeded(inlinee, blockIterator, block, invokeSuccessor);
+                iterator.inlineInvoke(code, inlinee, blockIterator, blocksToRemove, downcast);
+                strategy.updateTypeInformationIfNeeded(inlinee, blockIterator, block);
 
                 // If we inlined the invoke from a bridge method, it is no longer a bridge method.
                 if (method.accessFlags.isBridge()) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/InliningConstraints.java b/src/main/java/com/android/tools/r8/ir/optimize/InliningConstraints.java
index 129e9cb..de657de 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/InliningConstraints.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/InliningConstraints.java
@@ -190,8 +190,7 @@
   }
 
   public ConstraintWithTarget forMoveException() {
-    // TODO(64432527): Revisit this constraint.
-    return ConstraintWithTarget.NEVER;
+    return ConstraintWithTarget.ALWAYS;
   }
 
   public ConstraintWithTarget forNewArrayEmpty(DexType type, DexType invocationContext) {
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 2443d11..90554f6 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
@@ -20,8 +20,8 @@
 
   boolean isValidTarget(InvokeMethod invoke, DexEncodedMethod target, IRCode inlinee);
 
-  ListIterator<BasicBlock> updateTypeInformationIfNeeded(IRCode inlinee,
-      ListIterator<BasicBlock> blockIterator, BasicBlock block, BasicBlock invokeSuccessor);
+  void updateTypeInformationIfNeeded(
+      IRCode inlinee, ListIterator<BasicBlock> blockIterator, BasicBlock block);
 
   DexType getReceiverTypeIfKnown(InvokeMethod invoke);
 }
diff --git a/src/main/java/com/android/tools/r8/naming/MethodNameMinifier.java b/src/main/java/com/android/tools/r8/naming/MethodNameMinifier.java
index c6729e8..97f1228 100644
--- a/src/main/java/com/android/tools/r8/naming/MethodNameMinifier.java
+++ b/src/main/java/com/android/tools/r8/naming/MethodNameMinifier.java
@@ -14,6 +14,7 @@
 import com.android.tools.r8.shaking.RootSetBuilder.RootSet;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.MethodSignatureEquivalence;
+import com.android.tools.r8.utils.MethodSignatureRelaxedEquivalence;
 import com.android.tools.r8.utils.Timing;
 import com.google.common.base.Equivalence;
 import com.google.common.base.Equivalence.Wrapper;
@@ -90,11 +91,15 @@
  */
 class MethodNameMinifier extends MemberNameMinifier<DexMethod, DexProto> {
 
-  private final Equivalence<DexMethod> equivalence = MethodSignatureEquivalence.get();
+  private final Equivalence<DexMethod> equivalence;
   private final Map<DexCallSite, DexString> callSiteRenaming = new IdentityHashMap<>();
 
   MethodNameMinifier(AppInfoWithSubtyping appInfo, RootSet rootSet, InternalOptions options) {
     super(appInfo, rootSet, options);
+    equivalence =
+        overloadAggressively
+            ? MethodSignatureEquivalence.get()
+            : new MethodSignatureRelaxedEquivalence(appInfo);
   }
 
   @Override
@@ -337,10 +342,12 @@
   }
 
   private void addStatesToGlobalMapForMethod(
-      DexEncodedMethod method, Set<NamingState<DexProto, ?>> collectedStates,
+      DexEncodedMethod method,
+      Set<NamingState<DexProto, ?>> collectedStates,
       Map<Wrapper<DexMethod>, Set<NamingState<DexProto, ?>>> globalStateMap,
       Map<Wrapper<DexMethod>, Set<DexMethod>> sourceMethodsMap,
-      Map<Wrapper<DexMethod>, NamingState<DexProto, ?>> originStates, DexType originInterface) {
+      Map<Wrapper<DexMethod>, NamingState<DexProto, ?>> originStates,
+      DexType originInterface) {
     Wrapper<DexMethod> key = equivalence.wrap(method.method);
     Set<NamingState<DexProto, ?>> stateSet =
         globalStateMap.computeIfAbsent(key, k -> new HashSet<>());
diff --git a/src/main/java/com/android/tools/r8/utils/IteratorUtils.java b/src/main/java/com/android/tools/r8/utils/IteratorUtils.java
index 3cc3245..d0a126a 100644
--- a/src/main/java/com/android/tools/r8/utils/IteratorUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/IteratorUtils.java
@@ -5,6 +5,7 @@
 package com.android.tools.r8.utils;
 
 import java.util.ListIterator;
+import java.util.function.Predicate;
 
 public class IteratorUtils {
   public static <T> T peekPrevious(ListIterator<T> iterator) {
@@ -20,4 +21,25 @@
     assert previous == next;
     return next;
   }
+
+  public static <T> boolean allRemainingMatch(ListIterator<T> iterator, Predicate<T> predicate) {
+    return !anyRemainingMatch(iterator, remaining -> !predicate.test(remaining));
+  }
+
+  public static <T> boolean anyRemainingMatch(ListIterator<T> iterator, Predicate<T> predicate) {
+    T state = peekNext(iterator);
+    boolean result = false;
+    while (iterator.hasNext()) {
+      T item = iterator.next();
+      if (predicate.test(item)) {
+        result = true;
+        break;
+      }
+    }
+    while (iterator.hasPrevious() && iterator.previous() != state) {
+      // Restore the state of the iterator.
+    }
+    assert peekNext(iterator) == state;
+    return result;
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/utils/MethodSignatureRelaxedEquivalence.java b/src/main/java/com/android/tools/r8/utils/MethodSignatureRelaxedEquivalence.java
new file mode 100644
index 0000000..74d2d98
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/utils/MethodSignatureRelaxedEquivalence.java
@@ -0,0 +1,36 @@
+// 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 com.android.tools.r8.graph.AppInfo;
+import com.android.tools.r8.graph.DexMethod;
+import com.google.common.base.Equivalence;
+
+/**
+ * Implements an equivalence on {@link DexMethod} that does not take the holder into account but
+ * allow covariant return type: a method in a sub type can return a narrower type.
+ */
+public class MethodSignatureRelaxedEquivalence extends Equivalence<DexMethod> {
+
+  private final AppInfo appInfo;
+
+  public MethodSignatureRelaxedEquivalence(AppInfo appInfo) {
+    this.appInfo = appInfo;
+  }
+
+  @Override
+  protected boolean doEquivalent(DexMethod a, DexMethod b) {
+    return a.name.equals(b.name) && a.proto.parameters.equals(b.proto.parameters)
+        && (a.proto.returnType.equals(b.proto.returnType)
+            || (a.proto.returnType.isStrictSubtypeOf(b.proto.returnType, appInfo)
+                && a.getHolder().isStrictSubtypeOf(b.getHolder(), appInfo))
+            || (b.proto.returnType.isStrictSubtypeOf(a.proto.returnType, appInfo)
+                && b.getHolder().isStrictSubtypeOf(a.getHolder(), appInfo)));
+  }
+
+  @Override
+  protected int doHash(DexMethod method) {
+    return method.name.hashCode() * 31 + method.proto.parameters.hashCode();
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java b/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
index 180a5f8..d78f94b 100644
--- a/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
+++ b/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
@@ -985,27 +985,28 @@
               TestCondition.match(TestCondition.runtimes(DexVm.Version.V4_0_4)))
           .build();
 
-  public static List<String> requireInliningToBeDisabled = ImmutableList.of(
-      // Test for a specific stack trace that gets destroyed by inlining.
-      "492-checker-inline-invoke-interface",
-      "493-checker-inline-invoke-interface",
-      "488-checker-inline-recursive-calls",
-      "487-checker-inline-calls",
-      "122-npe",
-      "141-class-unload",
+  public static List<String> requireInliningToBeDisabled =
+      ImmutableList.of(
+          // Test for a specific stack trace that gets destroyed by inlining.
+          "008-exceptions",
+          "492-checker-inline-invoke-interface",
+          "493-checker-inline-invoke-interface",
+          "488-checker-inline-recursive-calls",
+          "487-checker-inline-calls",
+          "122-npe",
+          "141-class-unload",
 
-      // Calls some internal art methods that cannot tolerate inlining.
-      "466-get-live-vreg",
+          // Calls some internal art methods that cannot tolerate inlining.
+          "466-get-live-vreg",
 
-      // Requires a certain call pattern to surface an Art bug.
-      "534-checker-bce-deoptimization",
+          // Requires a certain call pattern to surface an Art bug.
+          "534-checker-bce-deoptimization",
 
-      // Requires something to be allocated in a method so that it goes out of scope.
-      "059-finalizer-throw",
+          // Requires something to be allocated in a method so that it goes out of scope.
+          "059-finalizer-throw",
 
-      // Has tests in submethods, which we should not inline.
-      "625-checker-licm-regressions"
-  );
+          // Has tests in submethods, which we should not inline.
+          "625-checker-licm-regressions");
 
   private static List<String> requireClassInliningToBeDisabled = ImmutableList.of(
       // Test is registered to be failing (failingRunWithArt), it fails only on 4.0.4
diff --git a/src/test/java/com/android/tools/r8/R8RunExamplesKotlinTest.java b/src/test/java/com/android/tools/r8/R8RunExamplesKotlinTest.java
index dc94a71..4451910 100644
--- a/src/test/java/com/android/tools/r8/R8RunExamplesKotlinTest.java
+++ b/src/test/java/com/android/tools/r8/R8RunExamplesKotlinTest.java
@@ -25,10 +25,16 @@
 
     List<String[]> fullTestList = new ArrayList<>(tests.length * 2);
     for (String test : tests) {
-      fullTestList.add(makeTest(Input.JAVAC, CompilerUnderTest.D8, CompilationMode.DEBUG, test));
-      fullTestList.add(makeTest(Input.JAVAC, CompilerUnderTest.D8, CompilationMode.RELEASE, test));
+      fullTestList.add(
+          makeTest(Input.JAVAC, CompilerUnderTest.D8, CompilationMode.DEBUG, test, Output.DEX));
+      fullTestList.add(
+          makeTest(Input.JAVAC, CompilerUnderTest.D8, CompilationMode.RELEASE, test, Output.DEX));
       fullTestList.add(makeTest(Input.DX, CompilerUnderTest.R8, CompilationMode.DEBUG, test));
       fullTestList.add(makeTest(Input.DX, CompilerUnderTest.R8, CompilationMode.RELEASE, test));
+      fullTestList.add(
+          makeTest(Input.JAVAC, CompilerUnderTest.R8, CompilationMode.DEBUG, test, Output.CF));
+      fullTestList.add(
+          makeTest(Input.JAVAC, CompilerUnderTest.R8, CompilationMode.RELEASE, test, Output.CF));
     }
     return fullTestList;
   }
diff --git a/src/test/java/com/android/tools/r8/debug/PostIncrementTestRunner.java b/src/test/java/com/android/tools/r8/debug/PostIncrementTestRunner.java
index 4cfb71a..6ddc9db 100644
--- a/src/test/java/com/android/tools/r8/debug/PostIncrementTestRunner.java
+++ b/src/test/java/com/android/tools/r8/debug/PostIncrementTestRunner.java
@@ -5,18 +5,24 @@
 
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.ToolHelper.DexVm;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
+import com.android.tools.r8.VmTestRunner;
+import com.android.tools.r8.VmTestRunner.IgnoreIfVmOlderOrEqualThan;
 import com.android.tools.r8.debug.DebugTestBase.JUnit3Wrapper.DebuggeeState;
 import java.util.stream.Stream;
 import org.junit.Assume;
 import org.junit.Test;
+import org.junit.runner.RunWith;
 
 // See b/80385846
+@RunWith(VmTestRunner.class)
 public class PostIncrementTestRunner extends DebugTestBase {
 
   private static final Class CLASS = PostIncrementTest.class;
   private static final String NAME = CLASS.getCanonicalName();
 
   @Test
+  @IgnoreIfVmOlderOrEqualThan(Version.V5_1_1)
   public void test() throws Exception {
     Assume.assumeTrue("Older runtimes cause some kind of debug streaming issues",
         ToolHelper.getDexVm().isNewerThan(DexVm.ART_5_1_1_HOST));
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/R8InliningTest.java b/src/test/java/com/android/tools/r8/ir/optimize/R8InliningTest.java
index dd7756b..8c5a738 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/R8InliningTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/R8InliningTest.java
@@ -90,7 +90,7 @@
     return Paths.get(temp.getRoot().getCanonicalPath(), DEFAULT_DEX_FILENAME);
   }
 
-  private String getGeneratedProguardMap() throws IOException {
+  private String getGeneratedProguardMap() {
     Path mapFile = temp.getRoot().toPath().resolve(DEFAULT_MAP_FILENAME);
     if (Files.exists(mapFile)) {
       return mapFile.toAbsolutePath().toString();
@@ -116,9 +116,14 @@
       commandBuilder.addProguardConfiguration(
           ImmutableList.of("-allowaccessmodification"), Origin.unknown());
     }
-    ToolHelper.runR8(commandBuilder.build(), o -> {
-      o.enableMinification = minification;
-    });
+    ToolHelper.runR8(
+        commandBuilder.build(),
+        o -> {
+          // Disable class inlining to prevent that the instantiation of Nullability is removed, and
+          // that the class is therefore made abstract.
+          o.enableClassInlining = false;
+          o.enableMinification = minification;
+        });
     String artOutput =
         ToolHelper.runArtNoVerificationErrors(out + "/classes.dex", "inlining.Inlining");
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlinerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlinerTest.java
index 5cdaac8..95343df 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlinerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlinerTest.java
@@ -9,10 +9,12 @@
 import static org.junit.Assert.fail;
 
 import com.android.tools.r8.OutputMode;
+import com.android.tools.r8.R8Command;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.ToolHelper.ProcessResult;
 import com.android.tools.r8.VmTestRunner;
+import com.android.tools.r8.ir.optimize.inliner.exceptionhandling.ExceptionHandlingTestClass;
 import com.android.tools.r8.ir.optimize.inliner.interfaces.InterfaceTargetsTestClass;
 import com.android.tools.r8.ir.optimize.inliner.interfaces.InterfaceTargetsTestClass.IfaceA;
 import com.android.tools.r8.ir.optimize.inliner.interfaces.InterfaceTargetsTestClass.IfaceB;
@@ -20,12 +22,15 @@
 import com.android.tools.r8.ir.optimize.inliner.interfaces.InterfaceTargetsTestClass.IfaceD;
 import com.android.tools.r8.ir.optimize.inliner.interfaces.InterfaceTargetsTestClass.IfaceNoImpl;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
+import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import com.google.common.collect.ImmutableList;
 import java.nio.file.Path;
+import java.util.List;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import org.junit.Test;
@@ -33,6 +38,30 @@
 
 @RunWith(VmTestRunner.class)
 public class InlinerTest extends TestBase {
+
+  @Test
+  public void testExceptionHandling() throws Exception {
+    String className = ExceptionHandlingTestClass.class.getName();
+    AndroidApp inputApp = readClasses(ExceptionHandlingTestClass.class);
+    List<String> proguardConfig =
+        ImmutableList.of(
+            "-keep public class " + className + "{",
+            "  public static void main(...);",
+            "}",
+            "-forceinline public class " + className + "{",
+            "  private static void inlinee*(...);",
+            "}",
+            "-neverinline public class " + className + "{",
+            "  private static void *Test(...);",
+            "}");
+    R8Command.Builder commandBuilder =
+        ToolHelper.prepareR8CommandBuilder(inputApp)
+            .addProguardConfiguration(proguardConfig, Origin.unknown());
+    ToolHelper.allowTestProguardOptions(commandBuilder);
+    AndroidApp outputApp = ToolHelper.runR8(commandBuilder.build(), this::configure);
+    assertEquals(runOnJava(ExceptionHandlingTestClass.class), runOnArt(outputApp, className));
+  }
+
   @Test
   public void testInterfacesWithoutTargets() throws Exception {
     byte[][] classes = {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/exceptionhandling/ExceptionHandlingTestClass.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/exceptionhandling/ExceptionHandlingTestClass.java
new file mode 100644
index 0000000..cda0856
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/exceptionhandling/ExceptionHandlingTestClass.java
@@ -0,0 +1,91 @@
+// 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.inliner.exceptionhandling;
+
+public class ExceptionHandlingTestClass {
+
+  private static boolean FALSE;
+
+  // -keep
+  public static void main(String[] args) {
+    FALSE = args == null;
+    try {
+      methodWithoutCatchHandlersTest(1);
+      System.out.println("Test succeeded: methodWithoutCatchHandlersTest(1)");
+    } catch (Exception e) {
+      System.out.println("Test failed: methodWithoutCatchHandlersTest(1)");
+    }
+    try {
+      methodWithoutCatchHandlersTest(2);
+      System.out.println("Test failed: methodWithoutCatchHandlersTest(2)");
+    } catch (Exception e) {
+      System.out.println("Test succeeded: methodWithoutCatchHandlersTest(2)");
+    }
+    try {
+      methodWithoutCatchHandlersTest(3);
+      System.out.println("Test failed: methodWithoutCatchHandlersTest(3)");
+    } catch (Exception e) {
+      System.out.println("Test succeeded: methodWithoutCatchHandlersTest(3)");
+    }
+
+    methodWithCatchHandlersTest();
+  }
+
+  // -neverinline
+  private static void methodWithoutCatchHandlersTest(int i) {
+    switch (i) {
+      case 1:
+        inlineeWithNormalExitThatDoesNotThrow();
+        break;
+
+      case 2:
+        inlineeWithNormalExitThatThrows();
+        break;
+
+      case 3:
+        inlineeWithoutNormalExit();
+        break;
+    }
+  }
+
+  // -neverinline
+  private static void methodWithCatchHandlersTest() {
+    try {
+      inlineeWithNormalExitThatDoesNotThrow();
+      System.out.println("Test succeeded: methodWithCatchHandlersTest(1)");
+    } catch (Exception e) {
+
+    }
+    try {
+      inlineeWithNormalExitThatThrows();
+    } catch (Exception e) {
+      System.out.println("Test succeeded: methodWithCatchHandlersTest(2)");
+    }
+    try {
+      inlineeWithoutNormalExit();
+    } catch (Exception e) {
+      System.out.println("Test succeeded: methodWithCatchHandlersTest(3)");
+    }
+  }
+
+  // -forceinline
+  private static void inlineeWithNormalExitThatDoesNotThrow() {
+    if (FALSE) {
+      throw new RuntimeException();
+    }
+  }
+
+  // -forceinline
+  private static void inlineeWithNormalExitThatThrows() {
+    if (!FALSE) {
+      throw new RuntimeException();
+    }
+  }
+
+  // -forceinline
+  private static void inlineeWithoutNormalExit() {
+    throw new RuntimeException();
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinLambdaMergingTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinLambdaMergingTest.java
index e43e94c..b8c4b47 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinLambdaMergingTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinLambdaMergingTest.java
@@ -270,42 +270,44 @@
   @Test
   public void testTrivialKs() throws Exception {
     final String mainClassName = "lambdas_kstyle_trivial.MainKt";
-    runTest("lambdas_kstyle_trivial", mainClassName, optionsModifier, (app) -> {
-      Verifier verifier = new Verifier(app);
-      String pkg = "lambdas_kstyle_trivial";
+    runTest(
+        "lambdas_kstyle_trivial",
+        mainClassName,
+        optionsModifier,
+        (app) -> {
+          Verifier verifier = new Verifier(app);
+          String pkg = "lambdas_kstyle_trivial";
 
-      verifier.assertLambdaGroups(
-          allowAccessModification ?
-              new Group[]{
-                  kstyle("", 0, 4),
-                  kstyle("", 1, 8),
-                  kstyle("", 2, 2), // -\
-                  kstyle("", 2, 5), // - 3 groups different by main method
-                  kstyle("", 2, 4), // -/
-                  kstyle("", 3, 2),
-                  kstyle("", 22, 2)} :
-              new Group[]{
-                  kstyle(pkg, 0, 2),
-                  kstyle(pkg, 1, 4),
-                  kstyle(pkg, 2, 5), // - 2 groups different by main method
-                  kstyle(pkg, 2, 4), // -/
-                  kstyle(pkg, 3, 2),
-                  kstyle(pkg, 22, 2),
-                  kstyle(pkg + "/inner", 0, 2),
-                  kstyle(pkg + "/inner", 1, 4)}
-      );
+          verifier.assertLambdaGroups(
+              allowAccessModification
+                  ? new Group[] {
+                    kstyle("", 0, 4),
+                    kstyle("", 1, 9),
+                    kstyle("", 2, 2), // -\
+                    kstyle("", 2, 5), // - 3 groups different by main method
+                    kstyle("", 2, 4), // -/
+                    kstyle("", 3, 2),
+                    kstyle("", 22, 2)
+                  }
+                  : new Group[] {
+                    kstyle(pkg, 0, 2),
+                    kstyle(pkg, 1, 5),
+                    kstyle(pkg, 2, 5), // - 2 groups different by main method
+                    kstyle(pkg, 2, 4), // -/
+                    kstyle(pkg, 3, 2),
+                    kstyle(pkg, 22, 2),
+                    kstyle(pkg + "/inner", 0, 2),
+                    kstyle(pkg + "/inner", 1, 4)
+                  });
 
-      verifier.assertLambdas(
-          allowAccessModification ?
-              new Lambda[]{
-                  new Lambda(pkg, "MainKt$testStateless$6", 1) /* Banned for limited inlining */} :
-              new Lambda[]{
-                  new Lambda(pkg, "MainKt$testStateless$6", 1), /* Banned for limited inlining */
-                  new Lambda(pkg, "MainKt$testStateless$8", 2),
-                  new Lambda(pkg + "/inner", "InnerKt$testInnerStateless$7", 2)}
-
-      );
-    });
+          verifier.assertLambdas(
+              allowAccessModification
+                  ? new Lambda[] {}
+                  : new Lambda[] {
+                    new Lambda(pkg, "MainKt$testStateless$8", 2),
+                    new Lambda(pkg + "/inner", "InnerKt$testInnerStateless$7", 2)
+                  });
+        });
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinxMetadataExtensionsServiceTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinxMetadataExtensionsServiceTest.java
index 87b9487..3eca971 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinxMetadataExtensionsServiceTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinxMetadataExtensionsServiceTest.java
@@ -31,7 +31,7 @@
 public class KotlinxMetadataExtensionsServiceTest extends TestBase {
 
   private void forkR8_kstyle_trivial(boolean allowAccessModification) throws Exception {
-    if  (!isRunR8Jar()) {
+    if (!isRunR8Jar()) {
       return;
     }
     Path working = temp.getRoot().toPath();
@@ -64,35 +64,34 @@
     Verifier verifier = new Verifier(inspector);
     String pkg = "lambdas_kstyle_trivial";
     verifier.assertLambdaGroups(
-        allowAccessModification ?
-            new Group[]{
-                kstyle("", 0, 4),
-                kstyle("", 1, 8),
-                kstyle("", 2, 2), // -\
-                kstyle("", 2, 5), // - 3 groups different by main method
-                kstyle("", 2, 4), // -/
-                kstyle("", 3, 2),
-                kstyle("", 22, 2)} :
-            new Group[]{
-                kstyle(pkg, 0, 2),
-                kstyle(pkg, 1, 4),
-                kstyle(pkg, 2, 5), // - 2 groups different by main method
-                kstyle(pkg, 2, 4), // -/
-                kstyle(pkg, 3, 2),
-                kstyle(pkg, 22, 2),
-                kstyle(pkg + "/inner", 0, 2),
-                kstyle(pkg + "/inner", 1, 4)}
-    );
+        allowAccessModification
+            ? new Group[] {
+              kstyle("", 0, 4),
+              kstyle("", 1, 9),
+              kstyle("", 2, 2), // -\
+              kstyle("", 2, 5), // - 3 groups different by main method
+              kstyle("", 2, 4), // -/
+              kstyle("", 3, 2),
+              kstyle("", 22, 2)
+            }
+            : new Group[] {
+              kstyle(pkg, 0, 2),
+              kstyle(pkg, 1, 5),
+              kstyle(pkg, 2, 5), // - 2 groups different by main method
+              kstyle(pkg, 2, 4), // -/
+              kstyle(pkg, 3, 2),
+              kstyle(pkg, 22, 2),
+              kstyle(pkg + "/inner", 0, 2),
+              kstyle(pkg + "/inner", 1, 4)
+            });
 
     verifier.assertLambdas(
-        allowAccessModification ?
-            new Lambda[]{
-                new Lambda(pkg, "MainKt$testStateless$6", 1) /* Banned for limited inlining */} :
-            new Lambda[]{
-                new Lambda(pkg, "MainKt$testStateless$6", 1), /* Banned for limited inlining */
-                new Lambda(pkg, "MainKt$testStateless$8", 2),
-                new Lambda(pkg + "/inner", "InnerKt$testInnerStateless$7", 2)}
-    );
+        allowAccessModification
+            ? new Lambda[] {}
+            : new Lambda[] {
+              new Lambda(pkg, "MainKt$testStateless$8", 2),
+              new Lambda(pkg + "/inner", "InnerKt$testInnerStateless$7", 2)
+            });
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/memberrebinding/CompositionalLenseTest.java b/src/test/java/com/android/tools/r8/memberrebinding/CompositionalLenseTest.java
index 6c6e69d..4903304 100644
--- a/src/test/java/com/android/tools/r8/memberrebinding/CompositionalLenseTest.java
+++ b/src/test/java/com/android/tools/r8/memberrebinding/CompositionalLenseTest.java
@@ -11,19 +11,24 @@
 import com.android.tools.r8.R8Command;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.code.InvokeVirtual;
-import com.android.tools.r8.graph.DexCode;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.FileUtils;
 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.InvokeInstructionSubject;
 import com.android.tools.r8.utils.codeinspector.MethodSubject;
 import com.google.common.collect.ImmutableList;
 import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
 import java.util.List;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
 
 // Base -> X:
 class Base {
@@ -47,10 +52,22 @@
   }
 }
 
+@RunWith(Parameterized.class)
 public class CompositionalLenseTest extends TestBase {
   private final static List<Class> CLASSES =
       ImmutableList.of(Base.class, Sub.class, TestMain.class);
 
+  private Backend backend;
+
+  @Parameterized.Parameters(name = "Backend: {0}")
+  public static Collection<Backend> data() {
+    return Arrays.asList(Backend.values());
+  }
+
+  public CompositionalLenseTest(Backend backend) {
+    this.backend = backend;
+  }
+
   @Test
   public void test() throws Exception {
     Path mapPath = temp.newFile("test-mapping.txt").toPath();
@@ -63,26 +80,38 @@
     FileUtils.writeTextFile(mapPath, pgMap);
 
     AndroidApp app = readClasses(CLASSES);
-    R8Command.Builder builder = ToolHelper.prepareR8CommandBuilder(app);
-    builder.addProguardConfiguration(
-        ImmutableList.of(
-            keepMainProguardConfiguration(TestMain.class),
-            "-applymapping " + mapPath,
-            "-dontobfuscate"),  // to use the renamed names in test-mapping.txt
-        Origin.unknown());
+    R8Command.Builder builder = ToolHelper.prepareR8CommandBuilder(app, emptyConsumer(backend));
+    builder
+        .addProguardConfiguration(
+            ImmutableList.of(
+                keepMainProguardConfiguration(TestMain.class),
+                "-applymapping " + mapPath,
+                "-dontobfuscate"), // to use the renamed names in test-mapping.txt
+            Origin.unknown())
+        .addLibraryFiles(runtimeJar(backend));
     AndroidApp processedApp = ToolHelper.runR8(builder.build(), options -> {
       options.enableInlining = false;
       options.enableClassMerging = false;
     });
-    CodeInspector codeInspector = new CodeInspector(processedApp);
+    CodeInspector codeInspector = new CodeInspector(processedApp, o -> o.enableCfFrontend = true);
     ClassSubject classSubject = codeInspector.clazz(TestMain.class);
     assertThat(classSubject, isPresent());
     MethodSubject methodSubject = classSubject.method(CodeInspector.MAIN);
     assertThat(methodSubject, isPresent());
-    DexCode dexCode = methodSubject.getMethod().getCode().asDexCode();
-    assertTrue(dexCode.instructions[2] instanceof InvokeVirtual);
-    InvokeVirtual invoke = (InvokeVirtual) dexCode.instructions[2];
-    DexMethod invokedMethod = invoke.getMethod();
+    Iterator<InstructionSubject> iterator = methodSubject.iterateInstructions();
+
+    InstructionSubject instruction = null;
+    boolean found = false;
+    while (iterator.hasNext()) {
+      instruction = iterator.next();
+      if (instruction.isInvokeVirtual()) {
+        found = true;
+        break;
+      }
+    }
+    assertTrue(found);
+
+    DexMethod invokedMethod = ((InvokeInstructionSubject) instruction).invokedMethod();
     assertEquals("bar", invokedMethod.name.toString());
     assertEquals("X", invokedMethod.getHolder().getName());
   }
diff --git a/src/test/java/com/android/tools/r8/naming/CovariantReturnTypeInSubInterfaceTest.java b/src/test/java/com/android/tools/r8/naming/CovariantReturnTypeInSubInterfaceTest.java
index 6602d0c..20f46b4 100644
--- a/src/test/java/com/android/tools/r8/naming/CovariantReturnTypeInSubInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/CovariantReturnTypeInSubInterfaceTest.java
@@ -7,15 +7,20 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertThat;
 
+import com.android.tools.r8.OutputMode;
 import com.android.tools.r8.TestBase;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.VmTestRunner;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.android.tools.r8.utils.codeinspector.MethodSubject;
 import com.google.common.collect.ImmutableList;
+import java.nio.file.Path;
 import java.util.List;
-import org.junit.Ignore;
 import org.junit.Test;
+import org.junit.runner.RunWith;
 
 interface SuperInterface {
   Super foo();
@@ -42,14 +47,14 @@
 class SuperImplementer implements SuperInterface {
   @Override
   public Super foo() {
-    return new Super();
+    return new Sub();
   }
 }
 
-class SubImplementer implements SubInterface {
+class SubImplementer extends SuperImplementer implements SubInterface {
   @Override
   public Sub foo() {
-    return new Sub();
+    return (Sub) super.foo();
   }
 }
 
@@ -57,19 +62,22 @@
   public static void main(String[] args) {
     SubImplementer subImplementer = new SubImplementer();
     Super sup = subImplementer.foo();
-    System.out.println(sup.bar());
+    System.out.print(sup.bar());
   }
 }
 
+@RunWith(VmTestRunner.class)
 public class CovariantReturnTypeInSubInterfaceTest extends TestBase {
 
-  @Ignore("b/112185748")
-  @Test
-  public void test() throws Exception {
+  private void test(boolean overloadAggressively) throws Exception {
+    String mainName = TestMain.class.getCanonicalName();
+    String aggressive =
+        overloadAggressively ? "-overloadaggressively" : "# Not overload aggressively";
     List<String> config = ImmutableList.of(
         "-printmapping",
         "-useuniqueclassmembernames",
-        "-keep class " + TestMain.class.getCanonicalName() + " {",
+        aggressive,
+        "-keep class " + mainName + " {",
         "  public void main(...);",
         "}",
         "-keep,allowobfuscation class **.Super* {",
@@ -88,7 +96,10 @@
         SubImplementer.class,
         TestMain.class
     );
-    AndroidApp processedApp = compileWithR8(app, String.join(System.lineSeparator(), config));
+    AndroidApp processedApp =
+        compileWithR8(app, String.join(System.lineSeparator(), config), options -> {
+          options.enableInlining = false;
+        });
     CodeInspector inspector = new CodeInspector(processedApp);
     ClassSubject superInterface = inspector.clazz(SuperInterface.class);
     assertThat(superInterface, isRenamed());
@@ -101,6 +112,24 @@
         Sub.class.getCanonicalName(), "foo", ImmutableList.of());
     assertThat(foo2, isRenamed());
     assertEquals(foo1.getFinalName(), foo2.getFinalName());
+
+    ProcessResult javaResult = ToolHelper.runJava(ToolHelper.getClassPathForTests(), mainName);
+    assertEquals(0, javaResult.exitCode);
+    Path outDex = temp.getRoot().toPath().resolve("dex.zip");
+    processedApp.writeToZip(outDex, OutputMode.DexIndexed);
+    ProcessResult artResult = ToolHelper.runArtNoVerificationErrorsRaw(outDex.toString(), mainName);
+    assertEquals(0, artResult.exitCode);
+    assertEquals(javaResult.stdout, artResult.stdout);
+  }
+
+  @Test
+  public void test_notAggressively() throws Exception {
+    test(false);
+  }
+
+  @Test
+  public void test_aggressively() throws Exception {
+    test(true);
   }
 
 }
diff --git a/src/test/java/com/android/tools/r8/naming/InterfaceRenamingTestRunner.java b/src/test/java/com/android/tools/r8/naming/InterfaceRenamingTestRunner.java
index e1fa3d0..ef6e0c8 100644
--- a/src/test/java/com/android/tools/r8/naming/InterfaceRenamingTestRunner.java
+++ b/src/test/java/com/android/tools/r8/naming/InterfaceRenamingTestRunner.java
@@ -14,12 +14,15 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.VmTestRunner;
 import com.android.tools.r8.origin.Origin;
 import java.nio.file.Path;
 import java.util.Arrays;
 import java.util.List;
 import org.junit.Test;
+import org.junit.runner.RunWith;
 
+@RunWith(VmTestRunner.class)
 public class InterfaceRenamingTestRunner extends TestBase {
   static final Class CLASS = InterfaceRenamingTest.class;
   static final Class[] CLASSES = InterfaceRenamingTest.CLASSES;
diff --git a/src/test/java/com/android/tools/r8/naming/LambdaRenamingTestRunner.java b/src/test/java/com/android/tools/r8/naming/LambdaRenamingTestRunner.java
index 02bca3a..56dce3a 100644
--- a/src/test/java/com/android/tools/r8/naming/LambdaRenamingTestRunner.java
+++ b/src/test/java/com/android/tools/r8/naming/LambdaRenamingTestRunner.java
@@ -16,13 +16,16 @@
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.VmTestRunner;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.FileUtils;
 import java.io.IOException;
 import java.nio.file.Path;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
 
+@RunWith(VmTestRunner.class)
 public class LambdaRenamingTestRunner extends TestBase {
   static final Class CLASS = LambdaRenamingTest.class;
   static final Class[] CLASSES = LambdaRenamingTest.CLASSES;
diff --git a/src/test/java/com/android/tools/r8/regress/b63935662/Regress63935662.java b/src/test/java/com/android/tools/r8/regress/b63935662/Regress63935662.java
index 01b0a17..86852ef 100644
--- a/src/test/java/com/android/tools/r8/regress/b63935662/Regress63935662.java
+++ b/src/test/java/com/android/tools/r8/regress/b63935662/Regress63935662.java
@@ -7,28 +7,53 @@
 import com.android.tools.r8.R8Command;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.dex.Constants;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.OffOrAuto;
 import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.Collection;
 import org.junit.Assert;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
 
+@RunWith(Parameterized.class)
 public class Regress63935662 extends TestBase {
 
+  private Backend backend;
+
+  @Parameterized.Parameters(name = "Backend: {0}")
+  public static Collection<Backend> data() {
+    return Arrays.asList(Backend.values());
+  }
+
+  public Regress63935662(Backend backend) {
+    this.backend = backend;
+  }
+
   void run(AndroidApp app, Class mainClass) throws Exception {
     Path proguardConfig =
         writeTextToTempFile(keepMainProguardConfiguration(mainClass, true, false));
-    R8Command command =
-        ToolHelper.prepareR8CommandBuilder(app)
-            .addProguardConfigurationFiles(proguardConfig)
-            .setMinApiLevel(AndroidApiLevel.L.getLevel())
-            .build();
+    R8Command.Builder builder =
+        ToolHelper.prepareR8CommandBuilder(app, emptyConsumer(backend))
+            .addLibraryFiles(runtimeJar(backend))
+            .addProguardConfigurationFiles(proguardConfig);
+    if (backend == Backend.DEX) {
+      builder.setMinApiLevel(AndroidApiLevel.L.getLevel());
+    }
     String resultFromJava = runOnJava(mainClass);
-    app = ToolHelper.runR8(command, options -> options.interfaceMethodDesugaring = OffOrAuto.Auto);
-    String resultFromArt = runOnArt(app, mainClass);
-    Assert.assertEquals(resultFromJava, resultFromArt);
+    app =
+        ToolHelper.runR8(
+            builder.build(), options -> options.interfaceMethodDesugaring = OffOrAuto.Auto);
+    String result;
+    if (backend == Backend.DEX) {
+      result = runOnArt(app, mainClass);
+    } else {
+      assert backend == Backend.CF;
+      result = runOnJava(app, mainClass);
+    }
+    Assert.assertEquals(resultFromJava, result);
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/rewrite/switchmaps/RewriteSwitchMapsTest.java b/src/test/java/com/android/tools/r8/rewrite/switchmaps/RewriteSwitchMapsTest.java
index b2bcb4e..ee99b38 100644
--- a/src/test/java/com/android/tools/r8/rewrite/switchmaps/RewriteSwitchMapsTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/switchmaps/RewriteSwitchMapsTest.java
@@ -4,7 +4,6 @@
 package com.android.tools.r8.rewrite.switchmaps;
 
 import com.android.tools.r8.CompilationMode;
-import com.android.tools.r8.DexIndexedConsumer;
 import com.android.tools.r8.R8Command;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.ToolHelper;
@@ -13,12 +12,28 @@
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.google.common.collect.ImmutableList;
 import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
 import org.junit.Assert;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
 
+@RunWith(Parameterized.class)
 public class RewriteSwitchMapsTest extends TestBase {
 
+  private Backend backend;
+
+  @Parameterized.Parameters(name = "Backend: {0}")
+  public static Collection<Backend> data() {
+    return Arrays.asList(Backend.values());
+  }
+
+  public RewriteSwitchMapsTest(Backend backend) {
+    this.backend = backend;
+  }
+
   private static final String JAR_FILE = "switchmaps.jar";
   private static final String SWITCHMAP_CLASS_NAME = "switchmaps.Switches$1";
   private static final List<String> PG_CONFIG = ImmutableList.of(
@@ -37,15 +52,16 @@
   }
 
   private void run(CompilationMode compilationMode) throws Exception {
-    R8Command command = R8Command.builder()
-        .addProgramFiles(Paths.get(ToolHelper.EXAMPLES_BUILD_DIR).resolve(JAR_FILE))
-        .addLibraryFiles(ToolHelper.getDefaultAndroidJar())
-        .addProguardConfiguration(PG_CONFIG, Origin.unknown())
-        .setMode(compilationMode)
-        .setProgramConsumer(DexIndexedConsumer.emptyConsumer())
-        .build();
+    R8Command command =
+        R8Command.builder()
+            .addProgramFiles(Paths.get(ToolHelper.EXAMPLES_BUILD_DIR).resolve(JAR_FILE))
+            .addLibraryFiles(runtimeJar(backend))
+            .addProguardConfiguration(PG_CONFIG, Origin.unknown())
+            .setMode(compilationMode)
+            .setProgramConsumer(emptyConsumer(backend))
+            .build();
     AndroidApp result = ToolHelper.runR8(command);
-    CodeInspector inspector = new CodeInspector(result);
+    CodeInspector inspector = new CodeInspector(result, o -> o.enableCfFrontend = true);
     Assert.assertFalse(inspector.clazz(SWITCHMAP_CLASS_NAME).isPresent());
   }
 }
diff --git a/src/test/java/com/android/tools/r8/shaking/B112290098.java b/src/test/java/com/android/tools/r8/shaking/B112290098.java
index 502da76..e7784cc 100644
--- a/src/test/java/com/android/tools/r8/shaking/B112290098.java
+++ b/src/test/java/com/android/tools/r8/shaking/B112290098.java
@@ -8,7 +8,6 @@
 
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.utils.AndroidApp;
-import org.junit.Ignore;
 import org.junit.Test;
 
 public class B112290098 extends TestBase {
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/inlining/IfRuleWithInlining.java b/src/test/java/com/android/tools/r8/shaking/ifrule/inlining/IfRuleWithInlining.java
index 4081836..d02fa5b 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/inlining/IfRuleWithInlining.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/inlining/IfRuleWithInlining.java
@@ -62,11 +62,10 @@
   @Parameters(name = "shrinker: {0} inlineMethod: {1}")
   public static Collection<Object[]> data() {
     // We don't run this on Proguard, as triggering inlining in Proguard is out of our control.
-    // TODO(b/64432527) Add configuration {Shrinker.R8_CF, true} when fixed. For now we fail to
-    // inline because of the exception handler.
     return ImmutableList.of(
         new Object[] {Shrinker.R8, true},
         new Object[] {Shrinker.R8, false},
+        new Object[] {Shrinker.R8_CF, true},
         new Object[] {Shrinker.R8_CF, false});
   }