diff --git a/src/main/java/com/android/tools/r8/cf/CfRegisterAllocator.java b/src/main/java/com/android/tools/r8/cf/CfRegisterAllocator.java
index b4a6009..22bbf46 100644
--- a/src/main/java/com/android/tools/r8/cf/CfRegisterAllocator.java
+++ b/src/main/java/com/android/tools/r8/cf/CfRegisterAllocator.java
@@ -7,6 +7,7 @@
 
 import com.android.tools.r8.ir.code.BasicBlock;
 import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.ir.code.IRCode.LiveAtEntrySets;
 import com.android.tools.r8.ir.code.Instruction;
 import com.android.tools.r8.ir.code.InstructionIterator;
 import com.android.tools.r8.ir.code.Phi;
@@ -25,7 +26,6 @@
 import java.util.Map;
 import java.util.NavigableSet;
 import java.util.PriorityQueue;
-import java.util.Set;
 import java.util.TreeSet;
 
 /**
@@ -41,7 +41,7 @@
   private final InternalOptions options;
 
   // Mapping from basic blocks to the set of values live at entry to that basic block.
-  private Map<BasicBlock, Set<Value>> liveAtEntrySets;
+  private Map<BasicBlock, LiveAtEntrySets> liveAtEntrySets;
 
   // List of all top-level live intervals for all SSA values.
   private final List<LiveIntervals> liveIntervals = new ArrayList<>();
@@ -106,7 +106,7 @@
     ImmutableList<BasicBlock> blocks = computeLivenessInformation();
     performLinearScan();
     if (options.debug) {
-      LinearScanRegisterAllocator.computeDebugInfo(blocks, liveIntervals, this);
+      LinearScanRegisterAllocator.computeDebugInfo(blocks, liveIntervals, this, liveAtEntrySets);
     }
   }
 
@@ -252,10 +252,10 @@
   }
 
   public void addToLiveAtEntrySet(BasicBlock block, Collection<Phi> phis) {
-    liveAtEntrySets.get(block).addAll(phis);
+    liveAtEntrySets.get(block).liveValues.addAll(phis);
   }
 
   public Collection<Value> getLocalsAtBlockEntry(BasicBlock block) {
-    return liveAtEntrySets.get(block);
+    return liveAtEntrySets.get(block).liveValues;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/cf/code/CfPosition.java b/src/main/java/com/android/tools/r8/cf/code/CfPosition.java
index 644f2c2..71900a9 100644
--- a/src/main/java/com/android/tools/r8/cf/code/CfPosition.java
+++ b/src/main/java/com/android/tools/r8/cf/code/CfPosition.java
@@ -41,7 +41,8 @@
 
   @Override
   public void buildIR(IRBuilder builder, CfState state, CfSourceCode code) {
-    state.setPosition(position);
-    builder.addDebugPosition(position);
+    Position canonical = code.getCanonicalPosition(position);
+    state.setPosition(canonical);
+    builder.addDebugPosition(canonical);
   }
 }
diff --git a/src/main/java/com/android/tools/r8/graph/CfCode.java b/src/main/java/com/android/tools/r8/graph/CfCode.java
index d588ab5..bd67a45 100644
--- a/src/main/java/com/android/tools/r8/graph/CfCode.java
+++ b/src/main/java/com/android/tools/r8/graph/CfCode.java
@@ -65,6 +65,11 @@
     public CfLabel getEnd() {
       return end;
     }
+
+    @Override
+    public String toString() {
+      return "" + index + " => " + local;
+    }
   }
 
   private final DexMethod method;
diff --git a/src/main/java/com/android/tools/r8/ir/code/DebugLocalWrite.java b/src/main/java/com/android/tools/r8/ir/code/DebugLocalWrite.java
index 6e4c464..ff126c6 100644
--- a/src/main/java/com/android/tools/r8/ir/code/DebugLocalWrite.java
+++ b/src/main/java/com/android/tools/r8/ir/code/DebugLocalWrite.java
@@ -14,8 +14,10 @@
  *
  * <p>All instructions may have attached local information (defined as the local information of
  * their outgoing value). This instruction is needed to mark a transition of an existing value (with
- * a possible local attached) to a new value that has a local (possibly the same one). If all
- * ingoing values end up having the same local this can be safely removed.
+ * a possible local attached) to a new value that has a local (possibly the same one). Even if the
+ * debug info of the ingoing value is equal to that of the outgoing value, the write may still be
+ * needed since an explicit end may have ended the visiblity range of the local which now becomes
+ * visible again.
  *
  * <p>For valid debug info, this instruction should have at least one debug user, denoting the end
  * of its range, and thus it should be live.
@@ -25,7 +27,6 @@
   public DebugLocalWrite(Value dest, Value src) {
     super(dest, src);
     assert dest.hasLocalInfo();
-    assert dest.getLocalInfo() != src.getLocalInfo() || src.isPhi();
   }
 
   @Override
diff --git a/src/main/java/com/android/tools/r8/ir/code/IRCode.java b/src/main/java/com/android/tools/r8/ir/code/IRCode.java
index 72728a8..0e2bc36 100644
--- a/src/main/java/com/android/tools/r8/ir/code/IRCode.java
+++ b/src/main/java/com/android/tools/r8/ir/code/IRCode.java
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.ir.code;
 
+import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.DebugLocalInfo;
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.utils.CfgPrinter;
@@ -25,6 +26,35 @@
 
 public class IRCode {
 
+  public static class LiveAtEntrySets {
+    // Set of live SSA values (regardless of whether they denote a local variable).
+    public final Set<Value> liveValues;
+
+    // Subset of live local-variable values.
+    public final Set<Value> liveLocalValues;
+
+    public LiveAtEntrySets(Set<Value> liveValues, Set<Value> liveLocalValues) {
+      assert liveValues.containsAll(liveLocalValues);
+      this.liveValues = liveValues;
+      this.liveLocalValues = liveLocalValues;
+    }
+
+    @Override
+    public int hashCode() {
+      throw new Unreachable();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      LiveAtEntrySets other = (LiveAtEntrySets) o;
+      return liveValues.equals(other.liveValues) && liveLocalValues.equals(other.liveLocalValues);
+    }
+
+    public boolean isEmpty() {
+      return liveValues.isEmpty() && liveLocalValues.isEmpty();
+    }
+  }
+
   // Stack marker to denote when all successors of a block have been processed when topologically
   // sorting.
   private static class BlockMarker {
@@ -72,8 +102,8 @@
   /**
    * Compute the set of live values at the entry to each block using a backwards data-flow analysis.
    */
-  public Map<BasicBlock, Set<Value>> computeLiveAtEntrySets() {
-    Map<BasicBlock, Set<Value>> liveAtEntrySets = new IdentityHashMap<>();
+  public Map<BasicBlock, LiveAtEntrySets> computeLiveAtEntrySets() {
+    Map<BasicBlock, LiveAtEntrySets> liveAtEntrySets = new IdentityHashMap<>();
     Queue<BasicBlock> worklist = new ArrayDeque<>();
     // Since this is a backwards data-flow analysis we process the blocks in reverse
     // topological order to reduce the number of iterations.
@@ -82,24 +112,37 @@
     while (!worklist.isEmpty()) {
       BasicBlock block = worklist.poll();
       Set<Value> live = new HashSet<>();
+      Set<Value> liveLocals = new HashSet<>();
       for (BasicBlock succ : block.getSuccessors()) {
-        Set<Value> succLiveAtEntry = liveAtEntrySets.get(succ);
-        if (succLiveAtEntry != null) {
-          live.addAll(succLiveAtEntry);
+        LiveAtEntrySets liveAtSucc = liveAtEntrySets.get(succ);
+        if (liveAtSucc != null) {
+          live.addAll(liveAtSucc.liveValues);
+          liveLocals.addAll(liveAtSucc.liveLocalValues);
         }
         int predIndex = succ.getPredecessors().indexOf(block);
         for (Phi phi : succ.getPhis()) {
-          live.add(phi.getOperand(predIndex));
+          Value operand = phi.getOperand(predIndex);
+          live.add(operand);
+          // TODO(zerny): Assert that operand.hasLocalInfo iff phi.hasLocalInfo
+          if (operand.hasLocalInfo()) {
+            liveLocals.add(operand);
+          }
           assert phi.getDebugValues().stream().allMatch(Value::needsRegister);
+          assert phi.getDebugValues().stream().allMatch(Value::hasLocalInfo);
           live.addAll(phi.getDebugValues());
+          liveLocals.addAll(phi.getDebugValues());
         }
       }
-      ListIterator<Instruction> iterator =
-          block.getInstructions().listIterator(block.getInstructions().size());
-      while (iterator.hasPrevious()) {
-        Instruction instruction = iterator.previous();
-        if (instruction.outValue() != null) {
-          live.remove(instruction.outValue());
+      Iterator<Instruction> iterator = block.getInstructions().descendingIterator();
+      while (iterator.hasNext()) {
+        Instruction instruction = iterator.next();
+        Value outValue = instruction.outValue();
+        if (outValue != null) {
+          live.remove(outValue);
+          assert outValue.hasLocalInfo() || !liveLocals.contains(outValue);
+          if (outValue.hasLocalInfo()) {
+            liveLocals.remove(outValue);
+          }
         }
         for (Value use : instruction.inValues()) {
           if (use.needsRegister()) {
@@ -107,15 +150,22 @@
           }
         }
         assert instruction.getDebugValues().stream().allMatch(Value::needsRegister);
+        assert instruction.getDebugValues().stream().allMatch(Value::hasLocalInfo);
         live.addAll(instruction.getDebugValues());
+        liveLocals.addAll(instruction.getDebugValues());
       }
       for (Phi phi : block.getPhis()) {
         live.remove(phi);
+        assert phi.hasLocalInfo() || !liveLocals.contains(phi);
+        if (phi.hasLocalInfo()) {
+          liveLocals.remove(phi);
+        }
       }
-      Set<Value> previousLiveAtEntry = liveAtEntrySets.put(block, live);
+      LiveAtEntrySets liveAtEntry = new LiveAtEntrySets(live, liveLocals);
+      LiveAtEntrySets previousLiveAtEntry = liveAtEntrySets.put(block, liveAtEntry);
       // If the live-at-entry set changed, add the predecessors to the worklist if they are not
       // already there.
-      if (previousLiveAtEntry == null || !previousLiveAtEntry.equals(live)) {
+      if (previousLiveAtEntry == null || !previousLiveAtEntry.equals(liveAtEntry)) {
         for (BasicBlock pred : block.getPredecessors()) {
           if (!worklist.contains(pred)) {
             worklist.add(pred);
@@ -123,8 +173,9 @@
         }
       }
     }
-    assert liveAtEntrySets.get(sorted.get(0)).size() == 0
-        : "Unexpected values live at entry to first block: " + liveAtEntrySets.get(sorted.get(0));
+    assert liveAtEntrySets.get(sorted.get(0)).isEmpty()
+        : "Unexpected values live at entry to first block: "
+        + liveAtEntrySets.get(sorted.get(0)).liveValues;
     return liveAtEntrySets;
   }
 
@@ -495,9 +546,14 @@
   }
 
   public boolean consistentBlockNumbering() {
-    return blocks.stream()
+    blocks
+        .stream()
         .collect(Collectors.groupingBy(BasicBlock::getNumber, Collectors.counting()))
-        .entrySet().stream().noneMatch((bb2count) -> bb2count.getValue() > 1);
+        .forEach(
+            (key, value) -> {
+              assert value == 1;
+            });
+    return true;
   }
 
   private boolean consistentBlockInstructions() {
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 7892afb..5f62c6c 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
@@ -366,46 +366,116 @@
   }
 
   @Override
+  public void buildBlockTransfer(
+      IRBuilder builder, int predecessorOffset, int successorOffset, boolean isExceptional) {
+    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());
+      }
+    }
+    // Manually compute the local variable change for the block transfer.
+    LocalVariableList atSource = getLocalVariables(predecessorOffset);
+    LocalVariableList atTarget = getLocalVariables(successorOffset);
+    if (!isExceptional) {
+      for (Entry<DebugLocalInfo> entry : atSource.locals.int2ObjectEntrySet()) {
+        if (atTarget.locals.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()) {
+        builder.addDebugLocalStart(entry.getIntKey(), entry.getValue());
+      }
+    }
+  }
+
+  @Override
   public void buildInstruction(
       IRBuilder builder, int instructionIndex, boolean firstBlockInstruction) {
     CfInstruction instruction = code.getInstructions().get(instructionIndex);
     currentInstructionIndex = instructionIndex;
     if (firstBlockInstruction) {
       currentBlockInfo = builder.getCFG().get(instructionIndex);
+      if (instructionIndex == 0 && currentBlockInfo == null) {
+        // If the entry block is also a target the actual entry block is at offset -1.
+        currentBlockInfo = builder.getCFG().get(IRBuilder.INITIAL_BLOCK_OFFSET);
+      }
       state.reset(incomingState.get(instructionIndex), instructionIndex == 0);
     }
+    assert currentBlockInfo != null;
     setLocalVariableLists();
-    readEndingLocals(builder);
-    if (currentBlockInfo != null && instruction.canThrow()) {
+
+    if (instruction.canThrow()) {
       Snapshot exceptionTransfer =
           state.getSnapshot().exceptionTransfer(builder.getFactory().throwableType);
       for (int target : currentBlockInfo.exceptionalSuccessors) {
         recordStateForTarget(target, exceptionTransfer);
       }
     }
-    if (isControlFlow(instruction)) {
-      ensureDebugValueLivenessControl(builder);
-      instruction.buildIR(builder, state, this);
-      Snapshot stateSnapshot = state.getSnapshot();
-      for (int target : getTargets(instructionIndex)) {
-        recordStateForTarget(target, stateSnapshot);
+
+    boolean localsChanged = localsChanged();
+    boolean hasNextInstructionInCurrentBlock =
+        instructionIndex + 1 != instructionCount()
+            && !builder.getCFG().containsKey(instructionIndex + 1);
+
+    if (instruction.isReturn() || instruction instanceof CfThrow) {
+      // Ensure that all live locals are marked as ending on method exits.
+      assert currentBlockInfo.normalSuccessors.isEmpty();
+      if (currentBlockInfo.exceptionalSuccessors.isEmpty()) {
+        incomingLocals.forEach(builder::addDebugLocalEnd);
+      } else if (!incomingLocals.isEmpty()) {
+        // If the throw instruction does not exit the method, we must end (ensure liveness of) all
+        // locals that are not kept live by at least one of the exceptional successors.
+        Int2ReferenceMap<DebugLocalInfo> live = new Int2ReferenceOpenHashMap<>();
+        for (int successorOffset : currentBlockInfo.exceptionalSuccessors) {
+          live.putAll(getLocalVariables(successorOffset).locals);
+        }
+        for (Entry<DebugLocalInfo> entry : incomingLocals.int2ObjectEntrySet()) {
+          if (live.get(entry.getIntKey()) != entry.getValue()) {
+            builder.addDebugLocalEnd(entry.getIntKey(), entry.getValue());
+          }
+        }
       }
-      state.clear();
-    } else {
-      if (instruction instanceof CfPosition) {
-        CfPosition cfPosition = (CfPosition) instruction;
-        Position position = cfPosition.getPosition();
-        CfPosition newCfPosition =
-            new CfPosition(cfPosition.getLabel(), getCanonicalPosition(position));
-        newCfPosition.buildIR(builder, state, this);
-      } else {
-        instruction.buildIR(builder, state, this);
-      }
-      ensureDebugValueLiveness(builder);
-      if (builder.getCFG().containsKey(currentInstructionIndex + 1)) {
-        recordStateForTarget(currentInstructionIndex + 1, state.getSnapshot());
-      }
+    } else if (localsChanged && hasNextInstructionInCurrentBlock) {
+      endLocals(builder);
     }
+
+    build(instruction, builder);
+    if (!hasNextInstructionInCurrentBlock) {
+      Snapshot stateSnapshot = state.getSnapshot();
+      if (isControlFlow(instruction)) {
+        for (int target : getTargets(instructionIndex)) {
+          recordStateForTarget(target, stateSnapshot);
+        }
+      } else {
+        recordStateForTarget(instructionIndex + 1, stateSnapshot);
+      }
+    } else if (localsChanged) {
+      startLocals(builder);
+    }
+  }
+
+  private void build(CfInstruction instruction, IRBuilder builder) {
+    instruction.buildIR(builder, state, this);
   }
 
   private void recordStateForTarget(int target, Snapshot snapshot) {
@@ -521,13 +591,24 @@
     }
   }
 
-  private void readEndingLocals(IRBuilder builder) {
-    if (!outgoingLocals.equals(incomingLocals)) {
-      // Add reads of locals ending after the current instruction.
-      for (Entry<DebugLocalInfo> entry : incomingLocals.int2ObjectEntrySet()) {
-        if (!entry.getValue().equals(outgoingLocals.get(entry.getIntKey()))) {
-          builder.addDebugLocalRead(entry.getIntKey(), entry.getValue());
-        }
+  private boolean localsChanged() {
+    return !incomingLocals.equals(outgoingLocals);
+  }
+
+  private void endLocals(IRBuilder builder) {
+    assert localsChanged();
+    for (Entry<DebugLocalInfo> entry : incomingLocals.int2ObjectEntrySet()) {
+      if (!entry.getValue().equals(outgoingLocals.get(entry.getIntKey()))) {
+        builder.addDebugLocalEnd(entry.getIntKey(), entry.getValue());
+      }
+    }
+  }
+
+  private void startLocals(IRBuilder builder) {
+    assert localsChanged();
+    for (Entry<DebugLocalInfo> entry : outgoingLocals.int2ObjectEntrySet()) {
+      if (!entry.getValue().equals(incomingLocals.get(entry.getIntKey()))) {
+        builder.addDebugLocalStart(entry.getIntKey(), entry.getValue());
       }
     }
   }
@@ -553,40 +634,6 @@
     return result;
   }
 
-  private void ensureDebugValueLiveness(IRBuilder builder) {
-    if (incomingLocals.equals(outgoingLocals)) {
-      return;
-    }
-    for (Entry<DebugLocalInfo> entry : incomingLocals.int2ObjectEntrySet()) {
-      if (entry.getValue().equals(outgoingLocals.get(entry.getIntKey()))) {
-        continue;
-      }
-      builder.addDebugLocalEnd(entry.getIntKey(), entry.getValue());
-    }
-    for (Entry<DebugLocalInfo> entry : outgoingLocals.int2ObjectEntrySet()) {
-      if (entry.getValue().equals(incomingLocals.get(entry.getIntKey()))) {
-        continue;
-      }
-      builder.addDebugLocalStart(entry.getIntKey(), entry.getValue());
-    }
-  }
-
-  private void ensureDebugValueLivenessControl(IRBuilder builder) {
-    if (incomingLocals.equals(outgoingLocals)) {
-      return;
-    }
-    for (Entry<DebugLocalInfo> entry : incomingLocals.int2ObjectEntrySet()) {
-      if (entry.getValue().equals(outgoingLocals.get(entry.getIntKey()))) {
-        continue;
-      }
-      builder.addDebugLocalRead(entry.getIntKey(), entry.getValue());
-    }
-    assert outgoingLocals
-        .int2ObjectEntrySet()
-        .stream()
-        .allMatch(entry -> entry.getValue().equals(incomingLocals.get(entry.getIntKey())));
-  }
-
   private boolean isControlFlow(CfInstruction currentInstruction) {
     return currentInstruction.isReturn()
         || currentInstruction.getTarget() != null
@@ -641,7 +688,7 @@
     return state.getPosition();
   }
 
-  private Position getCanonicalPosition(Position position) {
+  public Position getCanonicalPosition(Position position) {
     return canonicalPositions.getCanonical(
         new Position(
             position.line,
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/DexSourceCode.java b/src/main/java/com/android/tools/r8/ir/conversion/DexSourceCode.java
index 94516a2..81de890 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/DexSourceCode.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/DexSourceCode.java
@@ -164,6 +164,12 @@
   }
 
   @Override
+  public void buildBlockTransfer(
+      IRBuilder builder, int predecessorOffset, int successorOffset, boolean isExceptional) {
+    // Intentionally empty. Dex front-end does not support debug locals so no transfer info needed.
+  }
+
+  @Override
   public void buildInstruction(
       IRBuilder builder, int instructionIndex, boolean firstBlockInstruction) {
     updateCurrentCatchHandlers(instructionIndex);
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 3612944..5c4d581 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
@@ -54,6 +54,7 @@
 import com.android.tools.r8.ir.code.Invoke;
 import com.android.tools.r8.ir.code.Invoke.Type;
 import com.android.tools.r8.ir.code.InvokeCustom;
+import com.android.tools.r8.ir.code.JumpInstruction;
 import com.android.tools.r8.ir.code.MemberType;
 import com.android.tools.r8.ir.code.Monitor;
 import com.android.tools.r8.ir.code.MoveException;
@@ -137,18 +138,25 @@
   }
 
   private static class MoveExceptionWorklistItem extends WorklistItem {
+    private final int sourceOffset;
     private final int targetOffset;
 
-    private MoveExceptionWorklistItem(BasicBlock block, int targetOffset) {
+    private MoveExceptionWorklistItem(BasicBlock block, int sourceOffset, int targetOffset) {
       super(block, -1);
+      this.sourceOffset = sourceOffset;
       this.targetOffset = targetOffset;
     }
   }
 
   private static class SplitBlockWorklistItem extends WorklistItem {
+    private final int sourceOffset;
+    private final int targetOffset;
 
-    public SplitBlockWorklistItem(BasicBlock block) {
-      super(block, -1);
+    public SplitBlockWorklistItem(
+        int firstInstructionIndex, BasicBlock block, int sourceOffset, int targetOffset) {
+      super(block, firstInstructionIndex);
+      this.sourceOffset = sourceOffset;
+      this.targetOffset = targetOffset;
     }
   }
 
@@ -234,8 +242,9 @@
       return all;
     }
 
-    boolean hasJustOneNormalExit() {
-      return normalSuccessors.size() == 1 && exceptionalSuccessors.isEmpty();
+    boolean hasMoreThanASingleNormalExit() {
+      return normalSuccessors.size() > 1
+          || (normalSuccessors.size() == 1 && !exceptionalSuccessors.isEmpty());
     }
 
     BlockInfo split(
@@ -312,6 +321,8 @@
 
   private BasicBlock entryBlock = null;
   private BasicBlock currentBlock = null;
+  private int currentInstructionOffset = -1;
+
   final private ValueNumberGenerator valueNumberGenerator;
   private final DexEncodedMethod method;
   private final AppInfo appInfo;
@@ -324,7 +335,7 @@
 
   // Pending local reads.
   private Value previousLocalValue = null;
-  private final List<Value> debugLocalReads = new ArrayList<>();
+  private final List<Value> debugLocalEnds = new ArrayList<>();
 
   // Lazily populated list of local values that are referenced without being actually defined.
   private Int2ReferenceMap<List<Value>> uninitializedDebugLocalValues = null;
@@ -580,6 +591,7 @@
       if (item.block.isFilled()) {
         continue;
       }
+      assert debugLocalEnds.isEmpty();
       setCurrentBlock(item.block);
       blocks.add(currentBlock);
       currentBlock.setNumber(nextBlockNumber++);
@@ -589,10 +601,21 @@
         closeCurrentBlockGuaranteedNotToNeedEdgeSplitting();
         continue;
       }
-      // Split blocks are just pending close.
+      // Process split blocks which need to emit the locals transfer.
       if (item instanceof SplitBlockWorklistItem) {
-        closeCurrentBlockGuaranteedNotToNeedEdgeSplitting();
-        continue;
+        SplitBlockWorklistItem splitEdgeItem = (SplitBlockWorklistItem) item;
+        source.buildBlockTransfer(
+            this, splitEdgeItem.sourceOffset, splitEdgeItem.targetOffset, false);
+        if (item.firstInstructionIndex == -1) {
+          // If the block is a pure split-edge block emit goto (picks up local ends) and close.
+          addInstruction(new Goto(), Position.none());
+          closeCurrentBlockGuaranteedNotToNeedEdgeSplitting();
+          continue;
+        } else if (!debugLocalEnds.isEmpty()) {
+          // Otherwise, if some locals ended, insert a read so it takes place at the
+          // predecessor position.
+          addInstruction(new DebugLocalRead());
+        }
       }
       // Build IR for each dex instruction in the block.
       int instCount = source.instructionCount();
@@ -600,12 +623,14 @@
         if (currentBlock == null) {
           break;
         }
-        BlockInfo info = targets.get(source.instructionOffset(i));
+        int instructionOffset = source.instructionOffset(i);
+        BlockInfo info = targets.get(instructionOffset);
         if (info != null && info.block != currentBlock) {
-          closeCurrentBlockWithFallThrough(info.block);
           addToWorklist(info.block, i);
+          closeCurrentBlockWithFallThrough(info.block);
           break;
         }
+        currentInstructionOffset = instructionOffset;
         source.buildInstruction(this, i, i == item.firstInstructionIndex);
       }
     }
@@ -615,17 +640,29 @@
     // TODO(zerny): Link with outer try-block handlers, if any. b/65203529
     int targetIndex = source.instructionIndex(moveExceptionItem.targetOffset);
     int moveExceptionDest = source.getMoveExceptionRegister(targetIndex);
+    Position position = source.getCanonicalDebugPositionAtOffset(moveExceptionItem.targetOffset);
     if (moveExceptionDest >= 0) {
       Value out = writeRegister(moveExceptionDest, ValueType.OBJECT, ThrowingInfo.NO_THROW, null);
-      Position position = source.getCanonicalDebugPositionAtOffset(moveExceptionItem.targetOffset);
       MoveException moveException = new MoveException(out);
       moveException.setPosition(position);
       currentBlock.add(moveException);
     }
-    Goto exit = new Goto();
-    currentBlock.add(exit);
+    // The block-transfer for exceptional edges needs to inform that this is an exceptional transfer
+    // so that local ends become implicit. The reason for this issue is that the "split block" for
+    // and exceptional edge is *after* control transfer, so inserting an end will end up causing
+    // locals to remain live longer than they should. The problem with this is that it is now
+    // possible to resurrect a local by declaring debug info that does not contain the exception
+    // handler but then loading the value from the local index. This should not be a problem in
+    // practice since the stack is empty so the known case of extending the local liveness via the
+    // stack can't happen. If this does end up being an issue, it can potentially be solved by
+    // ending any local that could possibly end in any of the exceptional targets and then
+    // explicitly restart the local on each split-edge that does not end the local.
+    boolean isExceptionalEdge = true;
+    source.buildBlockTransfer(
+        this, moveExceptionItem.sourceOffset, moveExceptionItem.targetOffset, isExceptionalEdge);
     BasicBlock targetBlock = getTarget(moveExceptionItem.targetOffset);
     currentBlock.link(targetBlock);
+    addInstruction(new Goto(), position);
     addToWorklist(targetBlock, targetIndex);
   }
 
@@ -680,7 +717,7 @@
   private Value getIncomingLocalValue(int register, DebugLocalInfo local) {
     assert options.debug;
     assert local != null;
-    assert local == getIncomingLocal(register);
+    // TODO(b/111251032): Here we lookup a value with type based on debug info. That's just wrong!
     ValueType valueType = ValueType.fromDexType(local.type);
     return readRegisterIgnoreLocal(register, valueType, local);
   }
@@ -691,47 +728,24 @@
     return !value.isUninitializedLocal() && value.getLocalInfo() == local;
   }
 
-  public void addDebugLocalRead(int register, DebugLocalInfo local) {
-    if (!options.debug) {
-      return;
-    }
-    Value value = getIncomingLocalValue(register, local);
-    if (isValidFor(value, local)) {
-      debugLocalReads.add(value);
-    }
-  }
-
   public void addDebugLocalStart(int register, DebugLocalInfo local) {
     if (!options.debug) {
       return;
     }
     assert local != null;
-    assert local == getOutgoingLocal(register);
+    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);
-    // TODO(mathiasr): Here we create a Phi with type based on debug info. That's just wrong!
     Value incomingValue = readRegisterIgnoreLocal(register, valueType, local);
-
-    // TODO(mathiasr): This can be simplified once trivial phi removal is local-info aware.
-    if (incomingValue.isPhi() || incomingValue.getLocalInfo() != local) {
+    // If the local was not introduced by the previous instruction, start it here.
+    if (incomingValue.getLocalInfo() != local
+        || currentBlock.isEmpty()
+        || currentBlock.getInstructions().getLast().outValue() != incomingValue) {
       addDebugLocalWrite(ValueType.fromDexType(local.type), register, incomingValue);
-      return;
     }
-    assert incomingValue.getLocalInfo() == local;
-    assert !incomingValue.isUninitializedLocal();
-
-    // When inserting a start there are three possibilities:
-    // 1. The block is empty (eg, instructions from block entry until now materialized to nothing).
-    // 2. The block is non-empty and the last instruction defines the local to start.
-    // 3. The block is non-empty and the last instruction does not define the local to start.
-    if (currentBlock.getInstructions().isEmpty()) {
-      addInstruction(new DebugLocalRead());
-    }
-    Instruction instruction = currentBlock.getInstructions().getLast();
-    if (instruction.outValue() == incomingValue) {
-      return;
-    }
-    instruction.addDebugValue(incomingValue);
-    incomingValue.addDebugLocalStart(instruction);
   }
 
   public void addDebugLocalEnd(int register, DebugLocalInfo local) {
@@ -739,38 +753,18 @@
       return;
     }
     Value value = getIncomingLocalValue(register, local);
-    if (!isValidFor(value, local)) {
-      return;
-    }
-    // When inserting an end there are three possibilities:
-    // 1. The block is empty (eg, instructions from block entry until now materialized to nothing).
-    // 2. The block has an instruction not defining the local being ended.
-    // 3. The block has an instruction defining the local being ended.
-    if (currentBlock.getInstructions().isEmpty()) {
-      addInstruction(new DebugLocalRead());
-    }
-    Instruction instruction = currentBlock.getInstructions().getLast();
-    if (instruction.outValue() != value) {
-      instruction.addDebugValue(value);
-      value.addDebugLocalEnd(instruction);
-      return;
-    }
-    // In case 3. there are two cases:
-    // a. The defining instruction is a debug-write, in which case it should be removed.
-    // b. The defining instruction is overwriting the local value, in which case we de-associate it.
-    assert !instruction.outValue().isUsed();
-    if (instruction.isDebugLocalWrite()) {
-      DebugLocalWrite write = instruction.asDebugLocalWrite();
-      currentBlock.replaceCurrentDefinitions(value, write.src());
-      currentBlock.listIterator(write).removeOrReplaceByDebugLocalRead();
-    } else {
-      instruction.outValue().clearLocalInfo();
+    if (isValidFor(value, local)) {
+      debugLocalEnds.add(value);
     }
   }
 
   public void addDebugPosition(Position position) {
     if (options.debug) {
       assert source.getCurrentPosition().equals(position);
+      if (!debugLocalEnds.isEmpty()) {
+        // If there are pending local ends, end them before changing the line.
+        addInstruction(new DebugLocalRead(), Position.none());
+      }
       addInstruction(new DebugPosition());
     }
   }
@@ -1007,12 +1001,11 @@
   }
 
   public void addGoto(int targetOffset) {
-    addInstruction(new Goto());
     BasicBlock targetBlock = getTarget(targetOffset);
     assert !currentBlock.hasCatchSuccessor(targetBlock);
     currentBlock.link(targetBlock);
     addToWorklist(targetBlock, source.instructionIndex(targetOffset));
-    closeCurrentBlock();
+    closeCurrentBlock(new Goto());
   }
 
   private void addTrivialIf(int trueTargetOffset, int falseTargetOffset) {
@@ -1024,14 +1017,12 @@
     // We expected an if here and therefore we incremented the expected predecessor count
     // twice for the following block.
     target.decrementUnfilledPredecessorCount();
-    addInstruction(new Goto());
     currentBlock.link(target);
     addToWorklist(target, source.instructionIndex(trueTargetOffset));
-    closeCurrentBlock();
+    closeCurrentBlock(new Goto());
   }
 
   private void addNonTrivialIf(If instruction, int trueTargetOffset, int falseTargetOffset) {
-    addInstruction(instruction);
     BasicBlock trueTarget = getTarget(trueTargetOffset);
     BasicBlock falseTarget = getTarget(falseTargetOffset);
     currentBlock.link(trueTarget);
@@ -1039,7 +1030,7 @@
     // Generate fall-through before the block that is branched to.
     addToWorklist(falseTarget, source.instructionIndex(falseTargetOffset));
     addToWorklist(trueTarget, source.instructionIndex(trueTargetOffset));
-    closeCurrentBlock();
+    closeCurrentBlock(instruction);
   }
 
   public void addIf(If.Type type, ValueType operandType, int value1, int value2,
@@ -1406,8 +1397,7 @@
     // Attach the live locals to the return instruction to avoid a local change on monitor exit.
     attachLocalValues(ret);
     source.buildPostlude(this);
-    addInstruction(ret);
-    closeCurrentBlock();
+    closeCurrentBlock(ret);
   }
 
   public void addStaticGet(int dest, DexField field) {
@@ -1497,8 +1487,8 @@
     // Create a switch with only the non-fallthrough targets.
     keys = nonFallthroughKeys.toIntArray();
     labelOffsets = nonFallthroughOffsets.toIntArray();
-    addInstruction(createSwitch(switchValue, keys, fallthroughOffset, labelOffsets));
-    closeCurrentBlock();
+    Switch aSwitch = createSwitch(switchValue, keys, fallthroughOffset, labelOffsets);
+    closeCurrentBlock(aSwitch);
   }
 
   private Switch createSwitch(Value value, int[] keys, int fallthroughOffset, int[] targetOffsets) {
@@ -1537,6 +1527,9 @@
 
   public void addThrow(int value) {
     Value in = readRegister(value, ValueType.OBJECT);
+    // The only successors to a throw instruction are exceptional, so we directly add it (ensuring
+    // the exceptional edges which are split-edge by construction) and then we close the block which
+    // cannot have any additional edges that need splitting.
     addInstruction(new Throw(in));
     closeCurrentBlockGuaranteedNotToNeedEdgeSplitting();
   }
@@ -1932,7 +1925,8 @@
             header = new BasicBlock();
             header.incrementUnfilledPredecessorCount();
             moveExceptionHeaders.put(target, header);
-            ssaWorklist.add(new MoveExceptionWorklistItem(header, targetOffset));
+            ssaWorklist.add(
+                new MoveExceptionWorklistItem(header, currentInstructionOffset, targetOffset));
           }
           targets.add(header);
         }
@@ -1944,20 +1938,22 @@
   private void attachLocalValues(Instruction ir) {
     if (!options.debug) {
       assert previousLocalValue == null;
-      assert debugLocalReads.isEmpty();
+      assert debugLocalEnds.isEmpty();
       return;
     }
     // Add a use if this instruction is overwriting a previous value of the same local.
     if (previousLocalValue != null && previousLocalValue.getLocalInfo() == ir.getLocalInfo()) {
       assert ir.outValue() != null;
       ir.addDebugValue(previousLocalValue);
+      previousLocalValue.addDebugLocalEnd(ir);
     }
     // Add reads of locals if any are pending.
-    for (Value value : debugLocalReads) {
+    for (Value value : debugLocalEnds) {
       ir.addDebugValue(value);
+      value.addDebugLocalEnd(ir);
     }
     previousLocalValue = null;
-    debugLocalReads.clear();
+    debugLocalEnds.clear();
   }
 
   // Package (ie, SourceCode accessed) helpers.
@@ -2067,34 +2063,74 @@
   }
 
   private void closeCurrentBlockGuaranteedNotToNeedEdgeSplitting() {
-    // TODO(zerny): To ensure liveness of locals throughout the entire block, we might want to
-    // insert reads before closing the block. It is unclear if we can rely on a local-end to ensure
-    // liveness in all blocks where the local should be live.
     assert currentBlock != null;
     currentBlock.close(this);
     setCurrentBlock(null);
     throwingInstructionInCurrentBlock = false;
+    currentInstructionOffset = -1;
+    assert debugLocalEnds.isEmpty();
   }
 
-  private void closeCurrentBlock() {
+  private void closeCurrentBlock(JumpInstruction jumpInstruction) {
+    assert !jumpInstruction.instructionTypeCanThrow();
     assert currentBlock != null;
+    assert currentBlock.getInstructions().isEmpty()
+        || !currentBlock.getInstructions().getLast().isJumpInstruction();
+    generateSplitEdgeBlocks();
+    addInstruction(jumpInstruction);
+    closeCurrentBlockGuaranteedNotToNeedEdgeSplitting();
+  }
+
+  private void closeCurrentBlockWithFallThrough(BasicBlock nextBlock) {
+    assert currentBlock != null;
+    assert !currentBlock.hasCatchSuccessor(nextBlock);
+    currentBlock.link(nextBlock);
+    closeCurrentBlock(new Goto());
+  }
+
+  private void generateSplitEdgeBlocks() {
+    assert currentBlock != null;
+    assert currentBlock.isEmpty() || !currentBlock.getInstructions().getLast().isJumpInstruction();
     BlockInfo info = getBlockInfo(currentBlock);
-    if (!info.hasJustOneNormalExit()) {
+    if (info.hasMoreThanASingleNormalExit()) {
       // Exceptional edges are always split on construction, so no need to split edges to them.
+      // Introduce split-edge blocks for all normal edges and push them on the work list.
       for (int successorOffset : info.normalSuccessors) {
         BlockInfo successorInfo = getBlockInfo(successorOffset);
-        if (successorInfo.predecessorCount() > 1) {
+        if (successorInfo.predecessorCount() == 1) {
+          // re-add to worklist as a unique succ
+          WorklistItem oldItem = null;
+          for (WorklistItem item : ssaWorklist) {
+            if (item.block == successorInfo.block) {
+              oldItem = item;
+            }
+          }
+          assert oldItem.firstInstructionIndex == source.instructionIndex(successorOffset);
+          ssaWorklist.remove(oldItem);
+          ssaWorklist.add(
+              new SplitBlockWorklistItem(
+                  oldItem.firstInstructionIndex,
+                  oldItem.block,
+                  currentInstructionOffset,
+                  successorOffset));
+        } else {
           BasicBlock splitBlock = createSplitEdgeBlock(currentBlock, successorInfo.block);
-          ssaWorklist.add(new SplitBlockWorklistItem(splitBlock));
+          ssaWorklist.add(
+              new SplitBlockWorklistItem(
+                  -1, splitBlock, currentInstructionOffset, successorOffset));
         }
       }
+    } else if (info.normalSuccessors.size() == 1) {
+      int successorOffset = info.normalSuccessors.iterator().nextInt();
+      source.buildBlockTransfer(this, currentInstructionOffset, successorOffset, false);
+    } else {
+      // TODO(zerny): Consider refactoring to compute the live-at-exit via callback here too.
+      assert info.allSuccessors().isEmpty();
     }
-    closeCurrentBlockGuaranteedNotToNeedEdgeSplitting();
   }
 
   private static BasicBlock createSplitEdgeBlock(BasicBlock source, BasicBlock target) {
     BasicBlock splitBlock = new BasicBlock();
-    splitBlock.add(new Goto());
     splitBlock.incrementUnfilledPredecessorCount();
     splitBlock.getPredecessors().add(source);
     splitBlock.getSuccessors().add(target);
@@ -2103,14 +2139,6 @@
     return splitBlock;
   }
 
-  private void closeCurrentBlockWithFallThrough(BasicBlock nextBlock) {
-    assert currentBlock != null;
-    addInstruction(new Goto());
-    assert !currentBlock.hasCatchSuccessor(nextBlock);
-    currentBlock.link(nextBlock);
-    closeCurrentBlock();
-  }
-
   /**
    * Change to control-flow graph to avoid repeated phi operands when all the same values
    * flow in from multiple predecessors.
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 01c4dd0..e528a90 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
@@ -26,6 +26,7 @@
 import com.android.tools.r8.ir.code.ValueType;
 import com.android.tools.r8.ir.conversion.IRBuilder.BlockInfo;
 import com.android.tools.r8.ir.conversion.JarState.Local;
+import com.android.tools.r8.ir.conversion.JarState.LocalChangeAtOffset;
 import com.android.tools.r8.ir.conversion.JarState.Slot;
 import com.android.tools.r8.logging.Log;
 import it.unimi.dsi.fastutil.ints.Int2ReferenceMap;
@@ -467,6 +468,32 @@
   }
 
   @Override
+  public void buildBlockTransfer(
+      IRBuilder builder, int predecessorOffset, int successorOffset, boolean isExceptional) {
+    assert currentInstruction == null || predecessorOffset == getOffset(currentInstruction);
+    currentInstruction = null;
+    if (predecessorOffset == IRBuilder.INITIAL_BLOCK_OFFSET
+        || successorOffset == EXCEPTIONAL_SYNC_EXIT_OFFSET) {
+      return;
+    }
+    currentPosition = getCanonicalDebugPositionAtOffset(predecessorOffset);
+
+    LocalChangeAtOffset localChange = state.getLocalChange(predecessorOffset, successorOffset);
+    if (!isExceptional) {
+      for (Local toClose : localChange.getLocalsToClose()) {
+        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);
+      }
+    }
+  }
+
+  @Override
   public void buildInstruction(
       IRBuilder builder, int instructionIndex, boolean firstBlockInstruction) {
     if (instructionIndex == EXCEPTIONAL_SYNC_EXIT_OFFSET) {
@@ -482,13 +509,7 @@
     // current position will be updated by LineNumberNode into this block.
     if (firstBlockInstruction || instructionIndex == 0) {
       state.restoreState(instructionIndex);
-      // Don't include line changes when processing a label. Doing so will end up emitting local
-      // writes after the line has changed and thus causing locals to become visible too late.
-      currentPosition =
-          getCanonicalDebugPositionAtOffset(
-              ((instructionIndex > 0) && (insn instanceof LabelNode))
-                  ? instructionIndex - 1
-                  : instructionIndex);
+      currentPosition = getCanonicalDebugPositionAtOffset(instructionIndex);
     }
 
     String preInstructionState;
@@ -496,30 +517,20 @@
       preInstructionState = state.toString();
     }
 
-    if (firstBlockInstruction && insn != initialLabel) {
-      int offset = getOffset(insn);
-      state.beginTransactionAtBlockStart(offset);
-      assert state.getLocalsToClose().isEmpty();
-      for (Local local : state.getLocalsToOpen()) {
-        builder.addDebugLocalStart(local.slot.register, local.info);
-      }
-      state.endTransaction();
-    }
-
     boolean hasNextInstruction =
         instructionIndex + 1 != instructionCount()
             && !builder.getCFG().containsKey(instructionIndex + 1);
     state.beginTransaction(instructionIndex + 1, hasNextInstruction);
-    build(insn, builder);
-    if (hasNextInstruction || !isControlFlowInstruction(insn)) {
-      // We're either in straight-line code or at the end of a fallthrough block.
-      // Close locals starting at this point.
+    if (hasNextInstruction) {
+      // Explicitly end all locals ending at this point.
       for (Local local : state.getLocalsToClose()) {
         builder.addDebugLocalEnd(local.slot.register, local.info);
       }
     }
+    build(insn, builder);
+    // If the block continues past this instruction then local state should be updated.
     if (hasNextInstruction) {
-      // Open the scope of locals starting at this point.
+      // Ensure starts of locals starting at this point.
       for (Local local : state.getLocalsToOpen()) {
         builder.addDebugLocalStart(local.slot.register, local.info);
       }
@@ -536,6 +547,8 @@
             offset, instructionToString(insn), preInstructionState, state);
       }
     }
+
+    currentInstruction = null;
   }
 
   private boolean verifyExceptionEdgesAreRecorded(AbstractInsnNode insn) {
@@ -1862,23 +1875,12 @@
     }
   }
 
-  private void processLocalVariablesAtControlEdge(AbstractInsnNode insn, IRBuilder builder) {
-    assert isControlFlowInstruction(insn) && !isReturn(insn);
-    int offset = getOffset(insn);
-    int blockOffset = builder.getCFG().headMap(offset).lastIntKey();
-    BlockInfo blockInfo = builder.getCFG().get(blockOffset);
-    // Read all locals that are not live on all successors to ensure liveness.
-    for (Local local : state.localsNotLiveAtAllSuccessors(blockInfo.allSuccessors())) {
-      builder.addDebugLocalRead(local.slot.register, local.info);
-    }
-  }
-
   private void processLocalVariablesAtExit(AbstractInsnNode insn, IRBuilder builder) {
     assert isReturn(insn) || isThrow(insn);
     // Read all locals live at exit to ensure liveness.
     for (Local local : state.getLocals()) {
       if (local.info != null) {
-        builder.addDebugLocalRead(local.slot.register, local.info);
+        builder.addDebugLocalEnd(local.slot.register, local.info);
       }
     }
   }
@@ -2323,7 +2325,24 @@
     if (isExitingThrow(insn)) {
       processLocalVariablesAtExit(insn, builder);
     } else {
-      processLocalVariablesAtControlEdge(insn, builder);
+      int offset = getOffset(insn);
+      Int2ReferenceSortedMap<BlockInfo> cfg = builder.getCFG();
+      BlockInfo info = cfg.get(cfg.headMap(offset + 1).lastIntKey());
+      assert info.normalSuccessors.isEmpty();
+      assert !info.exceptionalSuccessors.isEmpty();
+      Int2ReferenceMap<DebugLocalInfo> ending = new Int2ReferenceOpenHashMap<>();
+      for (int successorOffset : info.exceptionalSuccessors) {
+        if (successorOffset == EXCEPTIONAL_SYNC_EXIT_OFFSET) {
+          // TODO(zerny): It would likely be beneficial to keep locals live until the exit from the
+          // exceptional sync exit block.
+          continue;
+        }
+        LocalChangeAtOffset localChange = state.getLocalChange(offset, successorOffset);
+        for (Local localEnd : localChange.getLocalsToClose()) {
+          ending.put(localEnd.slot.register, localEnd.info);
+        }
+      }
+      ending.forEach(builder::addDebugLocalEnd);
     }
     builder.addThrow(register);
   }
@@ -2659,7 +2678,6 @@
   }
 
   private void build(JumpInsnNode insn, IRBuilder builder) {
-    processLocalVariablesAtControlEdge(insn, builder);
     int[] targets = getTargets(insn);
     int opcode = insn.getOpcode();
     if (Opcodes.IFEQ <= opcode && opcode <= Opcodes.IF_ACMPNE) {
@@ -2749,12 +2767,10 @@
   }
 
   private void build(TableSwitchInsnNode insn, IRBuilder builder) {
-    processLocalVariablesAtControlEdge(insn, builder);
     buildSwitch(insn.dflt, insn.labels, new int[]{insn.min}, builder);
   }
 
   private void build(LookupSwitchInsnNode insn, IRBuilder builder) {
-    processLocalVariablesAtControlEdge(insn, builder);
     int[] keys = new int[insn.keys.size()];
     for (int i = 0; i < insn.keys.size(); i++) {
       keys[i] = (int) insn.keys.get(i);
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/JarState.java b/src/main/java/com/android/tools/r8/ir/conversion/JarState.java
index b67d12e..062905a 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/JarState.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/JarState.java
@@ -81,7 +81,7 @@
   }
 
   // Collection of locals information at a program point.
-  private static class LocalsAtOffset {
+  static class LocalsAtOffset {
     // Note that we assume live is always a super-set of starts.
     final List<LocalNodeInfo> live;
     final List<LocalNodeInfo> starts;
@@ -259,6 +259,41 @@
     }
   }
 
+  public static class LocalChangeAtOffset {
+
+    final LocalsAtOffset atExit;
+    final LocalsAtOffset atEntry;
+    private JarState state;
+
+    private LocalChangeAtOffset(LocalsAtOffset atExit, LocalsAtOffset atEntry, JarState state) {
+      this.atExit = atExit;
+      this.atEntry = atEntry;
+      this.state = state;
+    }
+
+    public List<Local> getLocalsToClose() {
+      List<Local> toClose = new ArrayList<>(atExit.live.size());
+      for (LocalNodeInfo liveAtExit : atExit.live) {
+        if (!atEntry.isLive(liveAtExit.info)) {
+          int register = state.getLocalRegister(liveAtExit.node.index, liveAtExit.type);
+          toClose.add(new Local(new Slot(register, liveAtExit.type), liveAtExit.info));
+        }
+      }
+      return toClose;
+    }
+
+    public List<Local> getLocalsToOpen() {
+      List<Local> toOpen = new ArrayList<>(atEntry.live.size());
+      for (LocalNodeInfo liveAtEntry : atEntry.live) {
+        if (!atExit.isLive(liveAtEntry.info)) {
+          int register = state.getLocalRegister(liveAtEntry.node.index, liveAtEntry.type);
+          toOpen.add(new Local(new Slot(register, liveAtEntry.type), liveAtEntry.info));
+        }
+      }
+      return toOpen;
+    }
+  }
+
   final int startOfStack;
   private int topOfStack;
 
@@ -529,6 +564,18 @@
     localsToClose.clear();
   }
 
+  private LocalsAtOffset getLocalsAtOffset(int offset) {
+    Int2ReferenceSortedMap<LocalsAtOffset> headMap = localsAtOffsetTable.headMap(offset + 1);
+    return localsAtOffsetTable.get(headMap.lastIntKey());
+  }
+
+  public LocalChangeAtOffset getLocalChange(int predecessorIndex, int successorIndex) {
+    return new LocalChangeAtOffset(
+        getLocalsAtOffset(predecessorIndex),
+        getLocalsAtOffset(successorIndex),
+        this);
+  }
+
   public List<Local> getLocalsToClose() {
     return localsToClose;
   }
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/SourceCode.java b/src/main/java/com/android/tools/r8/ir/conversion/SourceCode.java
index 2bc2aa1..9b5dc20 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/SourceCode.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/SourceCode.java
@@ -49,6 +49,9 @@
 
   void buildInstruction(IRBuilder builder, int instructionIndex, boolean firstBlockInstruction);
 
+  void buildBlockTransfer(
+      IRBuilder builder, int predecessorOffset, int successorOffset, boolean isExceptional);
+
   void buildPostlude(IRBuilder builder);
 
   // Helper to resolve switch payloads and build switch instructions (dex code only).
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
index df6e65a..b856cc5 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
@@ -2221,6 +2221,7 @@
             Value overwrittenLocal = instruction.removeDebugValue(localInfo);
             if (overwrittenLocal != null) {
               inValue.definition.addDebugValue(overwrittenLocal);
+              overwrittenLocal.addDebugLocalEnd(inValue.definition);
             }
             if (prevInstruction != null) {
               instruction.moveDebugValues(prevInstruction);
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java b/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java
index 5a7cba6..3e3413a 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Outliner.java
@@ -1022,6 +1022,12 @@
     }
 
     @Override
+    public void buildBlockTransfer(
+        IRBuilder builder, int predecessorOffset, int successorOffset, boolean isExceptional) {
+      throw new Unreachable("Outliner does not support control flow");
+    }
+
+    @Override
     public void buildPostlude(IRBuilder builder) {
       // Intentionally left empty. (Needed for Java-bytecode-frontend synchronization support.)
     }
diff --git a/src/main/java/com/android/tools/r8/ir/regalloc/LinearScanRegisterAllocator.java b/src/main/java/com/android/tools/r8/ir/regalloc/LinearScanRegisterAllocator.java
index 8fd09d0..0d93eee 100644
--- a/src/main/java/com/android/tools/r8/ir/regalloc/LinearScanRegisterAllocator.java
+++ b/src/main/java/com/android/tools/r8/ir/regalloc/LinearScanRegisterAllocator.java
@@ -17,6 +17,7 @@
 import com.android.tools.r8.ir.code.CheckCast;
 import com.android.tools.r8.ir.code.DebugLocalsChange;
 import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.ir.code.IRCode.LiveAtEntrySets;
 import com.android.tools.r8.ir.code.Instruction;
 import com.android.tools.r8.ir.code.InstructionListIterator;
 import com.android.tools.r8.ir.code.Invoke;
@@ -31,7 +32,6 @@
 import com.android.tools.r8.ir.regalloc.RegisterPositions.Type;
 import com.android.tools.r8.logging.Log;
 import com.android.tools.r8.utils.InternalOptions;
-import com.android.tools.r8.utils.ListUtils;
 import com.android.tools.r8.utils.StringUtils;
 import com.google.common.collect.HashMultiset;
 import com.google.common.collect.ImmutableList;
@@ -126,7 +126,7 @@
   private final InternalOptions options;
 
   // Mapping from basic blocks to the set of values live at entry to that basic block.
-  private Map<BasicBlock, Set<Value>> liveAtEntrySets;
+  private Map<BasicBlock, LiveAtEntrySets> liveAtEntrySets;
   // The value of the first argument, or null if the method has no arguments.
   protected Value firstArgumentValue;
   // The value of the last argument, or null if the method has no arguments.
@@ -254,12 +254,14 @@
   }
 
   private void computeDebugInfo(ImmutableList<BasicBlock> blocks) {
-    computeDebugInfo(blocks, liveIntervals, this);
+    computeDebugInfo(blocks, liveIntervals, this, liveAtEntrySets);
   }
 
   public static void computeDebugInfo(
-      ImmutableList<BasicBlock> blocks, List<LiveIntervals> liveIntervals,
-      RegisterAllocator allocator) {
+      ImmutableList<BasicBlock> blocks,
+      List<LiveIntervals> liveIntervals,
+      RegisterAllocator allocator,
+      Map<BasicBlock, LiveAtEntrySets> liveAtEntrySets) {
     // Collect live-ranges for all SSA values with local information.
     List<LocalRange> ranges = new ArrayList<>();
     for (LiveIntervals interval : liveIntervals) {
@@ -267,46 +269,19 @@
       if (!value.hasLocalInfo()) {
         continue;
       }
-      List<Integer> starts = ListUtils.map(value.getDebugLocalStarts(), Instruction::getNumber);
-      List<Integer> ends = ListUtils.map(value.getDebugLocalEnds(), Instruction::getNumber);
-      List<LiveRange> liveRanges = new ArrayList<>();
-      liveRanges.addAll(interval.getRanges());
+      List<LiveRange> liveRanges = new ArrayList<>(interval.getRanges());
       for (LiveIntervals child : interval.getSplitChildren()) {
         assert child.getValue() == value;
         assert child.getSplitChildren() == null || child.getSplitChildren().isEmpty();
         liveRanges.addAll(child.getRanges());
       }
       liveRanges.sort((r1, r2) -> Integer.compare(r1.start, r2.start));
-      starts.sort(Integer::compare);
-      ends.sort(Integer::compare);
-
       for (LiveRange liveRange : liveRanges) {
         int start = liveRange.start;
         int end = liveRange.end;
-        Integer nextEnd;
-        while ((nextEnd = nextInRange(start, end, ends)) != null) {
-          // If an argument value has been split, we have disallowed argument reuse and therefore,
-          // the argument value is also in the argument register throughout the method. For debug
-          // information, we always use the argument register whenever a local corresponds to an
-          // argument value. That avoids ending and restarting locals whenever we move arguments
-          // to lower register.
-          int register = allocator.getArgumentOrAllocateRegisterForValue(value, start);
-          ranges.add(new LocalRange(value, register, start, nextEnd));
-          Integer nextStart = nextInRange(nextEnd, end, starts);
-          if (nextStart == null) {
-            start = -1;
-            break;
-          }
-          start = nextStart;
-        }
-        if (start >= 0) {
-          ranges.add(
-              new LocalRange(
-                  value,
-                  allocator.getArgumentOrAllocateRegisterForValue(value, start),
-                  start,
-                  end));
-        }
+        ranges.add(
+            new LocalRange(
+                value, allocator.getArgumentOrAllocateRegisterForValue(value, start), start, end));
       }
     }
     if (ranges.isEmpty()) {
@@ -321,11 +296,33 @@
     Int2ReferenceMap<DebugLocalInfo> ending = new Int2ReferenceOpenHashMap<>();
     Int2ReferenceMap<DebugLocalInfo> starting = new Int2ReferenceOpenHashMap<>();
 
+    boolean isEntryBlock = true;
     for (BasicBlock block : blocks) {
-      // Skip past all spill moves to obtain the instruction number of the actual first instruction.
       InstructionListIterator instructionIterator = block.listIterator();
-      instructionIterator.nextUntil(
-          i -> !i.isArgument() && !i.isMoveException() && !isSpillInstruction(i));
+      Set<Value> liveLocalValues = new HashSet<>(liveAtEntrySets.get(block).liveLocalValues);
+      // Skip past arguments and open argument and phi locals.
+      if (isEntryBlock) {
+        isEntryBlock = false;
+        assert block.getPhis().isEmpty();
+        while (instructionIterator.hasNext()) {
+          Instruction instruction = instructionIterator.next();
+          if (!instruction.isArgument()) {
+            break;
+          }
+          if (instruction.outValue().hasLocalInfo()) {
+            liveLocalValues.add(instruction.outValue());
+          }
+        }
+        instructionIterator.previous();
+      } else {
+        for (Phi phi : block.getPhis()) {
+          if (phi.hasLocalInfo()) {
+            liveLocalValues.add(phi);
+          }
+        }
+      }
+      // Skip past all spill moves to obtain the instruction number of the actual first instruction.
+      instructionIterator.nextUntil(i -> !i.isMoveException() && !isSpillInstruction(i));
       Instruction firstInstruction = instructionIterator.previous();
       int firstIndex = firstInstruction.getNumber();
 
@@ -333,14 +330,18 @@
       // might be live upon entering the first instruction (if they are used by it). Since we
       // skipped move-exception this closes locals at the move exception which should close as part
       // of the exceptional transfer.
-      openRanges.removeIf(openRange -> !isLocalLiveAtInstruction(firstInstruction, openRange));
+      openRanges.removeIf(
+          openRange ->
+              !liveLocalValues.contains(openRange.value)
+                  || !isLocalLiveAtInstruction(firstInstruction, openRange));
 
       // Open ranges up-to but excluding the first instruction. Starts are inclusive but entry is
       // prior to the first instruction.
       while (nextStartingRange != null && nextStartingRange.start < firstIndex) {
         // If the range is live at this index open it. Again the end is inclusive here because the
         // instruction is live at block entry if it is live at entry to the first instruction.
-        if (isLocalLiveAtInstruction(firstInstruction, nextStartingRange)) {
+        if (liveLocalValues.contains(nextStartingRange.value)
+            && isLocalLiveAtInstruction(firstInstruction, nextStartingRange)) {
           openRanges.add(nextStartingRange);
         }
         nextStartingRange = rangeIterator.hasNext() ? rangeIterator.next() : null;
@@ -359,30 +360,51 @@
       // Iterate the block instructions and emit locals changed events.
       while (instructionIterator.hasNext()) {
         Instruction instruction = instructionIterator.next();
-        if (instruction.isDebugLocalRead()) {
-          // Remove debug local reads now that local liveness is computed.
-          assert !instruction.getDebugValues().isEmpty();
-          instruction.clearDebugValues();
-          instructionIterator.remove();
-        }
         if (!instructionIterator.hasNext()) {
           break;
         }
+
+        if (!instruction.getDebugValues().isEmpty()) {
+          for (Value endAnnotation : instruction.getDebugValues()) {
+            ListIterator<LocalRange> it = openRanges.listIterator();
+            while (it.hasNext()) {
+              LocalRange openRange = it.next();
+              if (openRange.value == endAnnotation) {
+                it.remove();
+                assert currentLocals.get(openRange.register) == openRange.local;
+                currentLocals.remove(openRange.register);
+                ending.put(openRange.register, openRange.local);
+                break;
+              }
+            }
+          }
+          // Remove the end markers now that local liveness is computed.
+          instruction.clearDebugValues();
+          if (instruction.isDebugLocalRead()) {
+            Instruction prev = instructionIterator.previous();
+            assert prev == instruction;
+            instructionIterator.remove();
+          }
+        }
+
         Instruction nextInstruction = instructionIterator.peekNext();
         if (isSpillInstruction(nextInstruction)) {
           // No need to insert a DebugLocalsChange instruction before a spill instruction.
           continue;
         }
         int index = nextInstruction.getNumber();
-        ListIterator<LocalRange> it = openRanges.listIterator(0);
-        while (it.hasNext()) {
-          LocalRange openRange = it.next();
-          // Close ranges up-to but excluding the first instruction.
-          if (!isLocalLiveAtInstruction(nextInstruction, openRange)) {
-            it.remove();
-            assert currentLocals.get(openRange.register) == openRange.local;
-            currentLocals.remove(openRange.register);
-            ending.put(openRange.register, openRange.local);
+        {
+          ListIterator<LocalRange> it = openRanges.listIterator();
+          while (it.hasNext()) {
+            LocalRange openRange = it.next();
+            // Close ranges up-to but excluding the first instruction.
+            if (!isLocalLiveAtInstruction(nextInstruction, openRange)) {
+              it.remove();
+              // It may be that currentLocals does not contain this local because an explicit end
+              // already closed the local.
+              currentLocals.remove(openRange.register);
+              ending.put(openRange.register, openRange.local);
+            }
           }
         }
         while (nextStartingRange != null && nextStartingRange.start < index) {
@@ -2292,7 +2314,7 @@
         int toInstruction = successor.entry().getNumber();
 
         // Insert spill/restore moves when a value changes across a block boundary.
-        Set<Value> liveAtEntry = liveAtEntrySets.get(successor);
+        Set<Value> liveAtEntry = liveAtEntrySets.get(successor).liveValues;
         for (Value value : liveAtEntry) {
           LiveIntervals parentInterval = value.getLiveIntervals();
           LiveIntervals fromIntervals = parentInterval.getSplitCovering(fromInstruction);
@@ -2388,8 +2410,8 @@
           LiveIntervals thisIntervals = thisValue.getLiveIntervals();
           thisIntervals.getRanges().clear();
           thisIntervals.addRange(new LiveRange(0, code.getNextInstructionNumber()));
-          for (Set<Value> values : liveAtEntrySets.values()) {
-            values.add(thisValue);
+          for (LiveAtEntrySets values : liveAtEntrySets.values()) {
+            values.liveValues.add(thisValue);
           }
           return;
         }
@@ -2397,20 +2419,18 @@
     }
   }
 
-  /**
-   * Compute live ranges based on liveAtEntry sets for all basic blocks.
-   */
+  /** Compute live ranges based on liveAtEntry sets for all basic blocks. */
   public static void computeLiveRanges(
       InternalOptions options,
       IRCode code,
-      Map<BasicBlock, Set<Value>> liveAtEntrySets,
+      Map<BasicBlock, LiveAtEntrySets> liveAtEntrySets,
       List<LiveIntervals> liveIntervals) {
     for (BasicBlock block : code.topologicallySortedBlocks()) {
       Set<Value> live = new HashSet<>();
       List<BasicBlock> successors = block.getSuccessors();
       Set<Value> phiOperands = new HashSet<>();
       for (BasicBlock successor : successors) {
-        live.addAll(liveAtEntrySets.get(successor));
+        live.addAll(liveAtEntrySets.get(successor).liveValues);
         for (Phi phi : successor.getPhis()) {
           live.remove(phi);
           phiOperands.add(phi.getOperand(successor.getPredecessors().indexOf(block)));
diff --git a/src/main/java/com/android/tools/r8/ir/synthetic/SyntheticSourceCode.java b/src/main/java/com/android/tools/r8/ir/synthetic/SyntheticSourceCode.java
index 991d371..3d416fb 100644
--- a/src/main/java/com/android/tools/r8/ir/synthetic/SyntheticSourceCode.java
+++ b/src/main/java/com/android/tools/r8/ir/synthetic/SyntheticSourceCode.java
@@ -192,6 +192,12 @@
   }
 
   @Override
+  public void buildBlockTransfer(
+      IRBuilder builder, int predecessorOffset, int successorOffset, boolean isExceptional) {
+    // Intensionally empty as synthetic code does not contain locals information.
+  }
+
+  @Override
   public final void resolveAndBuildSwitch(
       int value, int fallthroughOffset, int payloadOffset, IRBuilder builder) {
     throw new Unreachable("Unexpected call to resolveAndBuildSwitch");
diff --git a/src/main/java/com/android/tools/r8/naming/IdentifierNameStringMarker.java b/src/main/java/com/android/tools/r8/naming/IdentifierNameStringMarker.java
index 830391a..9db99ae 100644
--- a/src/main/java/com/android/tools/r8/naming/IdentifierNameStringMarker.java
+++ b/src/main/java/com/android/tools/r8/naming/IdentifierNameStringMarker.java
@@ -6,9 +6,9 @@
 import static com.android.tools.r8.naming.IdentifierNameStringUtils.identifyIdentiferNameString;
 import static com.android.tools.r8.naming.IdentifierNameStringUtils.inferMemberOrTypeFromNameString;
 import static com.android.tools.r8.naming.IdentifierNameStringUtils.isReflectionMethod;
-import static com.android.tools.r8.naming.IdentifierNameStringUtils.warnUndeterminedIdentifierIfNecessary;
 
 import com.android.tools.r8.graph.AppInfo;
+import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexField;
@@ -32,8 +32,11 @@
 import com.android.tools.r8.ir.code.InvokeMethod;
 import com.android.tools.r8.ir.code.StaticPut;
 import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.position.TextPosition;
 import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
 import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.StringDiagnostic;
 import com.google.common.collect.Streams;
 import it.unimi.dsi.fastutil.objects.Object2BooleanMap;
 import java.util.Arrays;
@@ -105,24 +108,19 @@
           if (!identifierNameStrings.containsKey(field)) {
             continue;
           }
-          boolean isExplicitRule = identifierNameStrings.getBoolean(field);
           Value in = instruction.isStaticPut()
               ? instruction.asStaticPut().inValue()
               : instruction.asInstancePut().value();
           if (!in.isConstString()) {
-            if (isExplicitRule) {
-              warnUndeterminedIdentifierIfNecessary(
-                  appInfo, options, field, originHolder, instruction, null);
-            }
+            warnUndeterminedIdentifierIfNecessary(
+                appInfo, options, field, originHolder, instruction, null);
             continue;
           }
           DexString original = in.getConstInstruction().asConstString().getValue();
           DexItemBasedString itemBasedString = inferMemberOrTypeFromNameString(appInfo, original);
           if (itemBasedString == null) {
-            if (isExplicitRule) {
-              warnUndeterminedIdentifierIfNecessary(
-                  appInfo, options, field, originHolder, instruction, original);
-            }
+            warnUndeterminedIdentifierIfNecessary(
+                appInfo, options, field, originHolder, instruction, original);
             continue;
           }
           // Move the cursor back to $fieldPut
@@ -171,16 +169,13 @@
           if (!identifierNameStrings.containsKey(invokedMethod)) {
             continue;
           }
-          boolean isExplicitRule = identifierNameStrings.getBoolean(invokedMethod);
           List<Value> ins = invoke.arguments();
           Value[] changes = new Value [ins.size()];
           if (isReflectionMethod(dexItemFactory, invokedMethod)) {
             DexItemBasedString itemBasedString = identifyIdentiferNameString(appInfo, invoke);
             if (itemBasedString == null) {
-              if (isExplicitRule) {
-                warnUndeterminedIdentifierIfNecessary(
-                    appInfo, options, invokedMethod, originHolder, instruction, null);
-              }
+              warnUndeterminedIdentifierIfNecessary(
+                  appInfo, options, invokedMethod, originHolder, instruction, null);
               continue;
             }
             DexType returnType = invoke.getReturnType();
@@ -225,20 +220,16 @@
             for (int i = 0; i < ins.size(); i++) {
               Value in = ins.get(i);
               if (!in.isConstString()) {
-                if (isExplicitRule) {
-                  warnUndeterminedIdentifierIfNecessary(
-                      appInfo, options, invokedMethod, originHolder, instruction, null);
-                }
+                warnUndeterminedIdentifierIfNecessary(
+                    appInfo, options, invokedMethod, originHolder, instruction, null);
                 continue;
               }
               DexString original = in.getConstInstruction().asConstString().getValue();
               DexItemBasedString itemBasedString =
                   inferMemberOrTypeFromNameString(appInfo, original);
               if (itemBasedString == null) {
-                if (isExplicitRule) {
-                  warnUndeterminedIdentifierIfNecessary(
-                      appInfo, options, invokedMethod, originHolder, instruction, original);
-                }
+                warnUndeterminedIdentifierIfNecessary(
+                    appInfo, options, invokedMethod, originHolder, instruction, original);
                 continue;
               }
               // Move the cursor back to $invoke
@@ -292,4 +283,43 @@
       }
     }
   }
+
+  private void warnUndeterminedIdentifierIfNecessary(
+      AppInfo appInfo,
+      InternalOptions options,
+      DexItem member,
+      DexType originHolder,
+      Instruction instruction,
+      DexString original) {
+    assert member instanceof DexField || member instanceof DexMethod;
+    // Only issue warnings for -identifiernamestring rules explicitly added by the user.
+    boolean matchedByExplicitRule = identifierNameStrings.getBoolean(member);
+    if (!matchedByExplicitRule) {
+      return;
+    }
+    DexClass originClass = appInfo.definitionFor(originHolder);
+    // If the origin is a library class, it is out of developers' control.
+    if (originClass != null && originClass.isLibraryClass()) {
+      return;
+    }
+    // Undetermined identifiers matter only if minification is enabled.
+    if (!options.proguardConfiguration.isObfuscating()) {
+      return;
+    }
+    Origin origin = appInfo.originFor(originHolder);
+    String kind = member instanceof DexField ? "field" : "method";
+    String originalMessage = original == null ? "what identifier string flows to "
+        : "what '" + original.toString() + "' refers to, which flows to ";
+    String message =
+        "Cannot determine " + originalMessage + member.toSourceString()
+            + " that is specified in -identifiernamestring rules."
+            + " Thus, not all identifier strings flowing to that " + kind
+            + " are renamed, which can cause resolution failures at runtime.";
+    StringDiagnostic diagnostic =
+        instruction.getPosition().line >= 1
+            ? new StringDiagnostic(message, origin,
+            new TextPosition(0L, instruction.getPosition().line, 1))
+            : new StringDiagnostic(message, origin);
+    options.reporter.warning(diagnostic);
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/naming/IdentifierNameStringUtils.java b/src/main/java/com/android/tools/r8/naming/IdentifierNameStringUtils.java
index bf23f59..4c64cf6 100644
--- a/src/main/java/com/android/tools/r8/naming/IdentifierNameStringUtils.java
+++ b/src/main/java/com/android/tools/r8/naming/IdentifierNameStringUtils.java
@@ -9,7 +9,6 @@
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexEncodedMethod;
-import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexItem;
 import com.android.tools.r8.graph.DexItemBasedString;
 import com.android.tools.r8.graph.DexItemFactory;
@@ -24,10 +23,6 @@
 import com.android.tools.r8.ir.code.InstructionIterator;
 import com.android.tools.r8.ir.code.InvokeMethod;
 import com.android.tools.r8.ir.code.Value;
-import com.android.tools.r8.origin.Origin;
-import com.android.tools.r8.position.TextPosition;
-import com.android.tools.r8.utils.InternalOptions;
-import com.android.tools.r8.utils.StringDiagnostic;
 import it.unimi.dsi.fastutil.ints.Int2ObjectArrayMap;
 import java.util.List;
 import java.util.Map;
@@ -371,38 +366,4 @@
     }
     return new DexTypeList(types);
   }
-
-  public static void warnUndeterminedIdentifierIfNecessary(
-      AppInfo appInfo,
-      InternalOptions options,
-      DexItem member,
-      DexType originHolder,
-      Instruction instruction,
-      DexString original) {
-    assert member instanceof DexField || member instanceof DexMethod;
-    DexClass originClass = appInfo.definitionFor(originHolder);
-    // If the origin is a library class, it is out of developers' control.
-    if (originClass != null && originClass.isLibraryClass()) {
-      return;
-    }
-    // Undetermined identifiers matter only if minification is enabled.
-    if (!options.proguardConfiguration.isObfuscating()) {
-      return;
-    }
-    Origin origin = appInfo.originFor(originHolder);
-    String kind = member instanceof DexField ? "field" : "method";
-    String originalMessage = original == null ? "what identifier string flows to "
-        : "what '" + original.toString() + "' refers to, which flows to ";
-    String message =
-        "Cannot determine " + originalMessage + member.toSourceString()
-            + " that is specified in -identifiernamestring rules."
-            + " Thus, not all identifier strings flowing to that " + kind
-            + " are renamed, which can cause resolution failures at runtime.";
-    StringDiagnostic diagnostic =
-        instruction.getPosition().line >= 1
-            ? new StringDiagnostic(message, origin,
-                new TextPosition(0L, instruction.getPosition().line, 1))
-            : new StringDiagnostic(message, origin);
-    options.reporter.warning(diagnostic);
-  }
 }
diff --git a/src/test/java/com/android/tools/r8/TestBase.java b/src/test/java/com/android/tools/r8/TestBase.java
index bb2db07..67fcb59 100644
--- a/src/test/java/com/android/tools/r8/TestBase.java
+++ b/src/test/java/com/android/tools/r8/TestBase.java
@@ -16,7 +16,6 @@
 import com.android.tools.r8.graph.SmaliWriter;
 import com.android.tools.r8.jasmin.JasminBuilder;
 import com.android.tools.r8.origin.Origin;
-import com.android.tools.r8.shaking.ProguardRuleParserException;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.AndroidAppConsumers;
@@ -45,7 +44,6 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
-import java.util.concurrent.ExecutionException;
 import java.util.function.Consumer;
 import java.util.jar.JarOutputStream;
 import java.util.stream.Stream;
@@ -55,7 +53,6 @@
 import org.junit.rules.TemporaryFolder;
 
 public class TestBase {
-
   protected enum Backend {
     CF,
     DEX
@@ -316,108 +313,75 @@
     return String.join(".", parts);
   }
 
-  /**
-   * Compile an application with D8.
-   */
-  protected AndroidApp compileWithD8(AndroidApp app)
-      throws ExecutionException, IOException, CompilationFailedException {
+  /** Compile an application with D8. */
+  protected AndroidApp compileWithD8(AndroidApp app) throws CompilationFailedException {
     D8Command.Builder builder = ToolHelper.prepareD8CommandBuilder(app);
     AndroidAppConsumers appSink = new AndroidAppConsumers(builder);
     D8.run(builder.build());
     return appSink.build();
   }
 
-  /**
-   * Compile an application with D8.
-   */
+  /** Compile an application with D8. */
   protected AndroidApp compileWithD8(AndroidApp app, Consumer<InternalOptions> optionsConsumer)
-      throws ExecutionException, IOException, CompilationFailedException {
+      throws IOException, CompilationFailedException {
     return ToolHelper.runD8(app, optionsConsumer);
   }
 
-  /**
-   * Compile an application with R8.
-   */
-  protected AndroidApp compileWithR8(Class... classes)
-      throws ProguardRuleParserException, ExecutionException, IOException,
-      CompilationFailedException {
+  /** Compile an application with R8. */
+  protected AndroidApp compileWithR8(Class... classes) throws IOException {
     return ToolHelper.runR8(readClasses(classes));
   }
 
-  /**
-   * Compile an application with R8.
-   */
+  /** Compile an application with R8. */
   protected AndroidApp compileWithR8(List<Class> classes)
-      throws ProguardRuleParserException, ExecutionException, IOException,
-      CompilationFailedException {
+      throws IOException, CompilationFailedException {
     R8Command command = ToolHelper.prepareR8CommandBuilder(readClasses(classes)).build();
     return ToolHelper.runR8(command);
   }
 
-  /**
-   * Compile an application with R8.
-   */
+  /** Compile an application with R8. */
   protected AndroidApp compileWithR8(List<Class> classes, Consumer<InternalOptions> optionsConsumer)
-      throws ProguardRuleParserException, ExecutionException, IOException,
-      CompilationFailedException {
+      throws IOException, CompilationFailedException {
     R8Command command = ToolHelper.prepareR8CommandBuilder(readClasses(classes)).build();
     return ToolHelper.runR8(command, optionsConsumer);
   }
 
-  /**
-   * Compile an application with R8.
-   */
+  /** Compile an application with R8. */
   protected AndroidApp compileWithR8(AndroidApp app)
-      throws ProguardRuleParserException, ExecutionException, IOException,
-      CompilationFailedException {
+      throws IOException, CompilationFailedException {
     R8Command command = ToolHelper.prepareR8CommandBuilder(app).build();
     return ToolHelper.runR8(command);
   }
 
-  /**
-   * Compile an application with R8.
-   */
+  /** Compile an application with R8. */
   protected AndroidApp compileWithR8(AndroidApp app, Consumer<InternalOptions> optionsConsumer)
-      throws ProguardRuleParserException, ExecutionException, IOException,
-      CompilationFailedException {
+      throws IOException, CompilationFailedException {
     R8Command command = ToolHelper.prepareR8CommandBuilder(app).build();
     return ToolHelper.runR8(command, optionsConsumer);
   }
 
-  /**
-   * Compile an application with R8 using the supplied proguard configuration.
-   */
+  /** Compile an application with R8 using the supplied proguard configuration. */
   protected AndroidApp compileWithR8(List<Class> classes, String proguardConfig)
-      throws ProguardRuleParserException, ExecutionException, IOException,
-      CompilationFailedException {
+      throws IOException, CompilationFailedException {
     return compileWithR8(readClasses(classes), proguardConfig);
   }
 
-  /**
-   * Compile an application with R8 using the supplied proguard configuration.
-   */
+  /** Compile an application with R8 using the supplied proguard configuration. */
   protected AndroidApp compileWithR8(
       List<Class> classes, String proguardConfig, Consumer<InternalOptions> optionsConsumer)
-      throws ProguardRuleParserException, ExecutionException, IOException,
-      CompilationFailedException {
+      throws IOException, CompilationFailedException {
     return compileWithR8(readClasses(classes), proguardConfig, optionsConsumer);
   }
 
-  /**
-   * Compile an application with R8 using the supplied proguard configuration.
-   */
+  /** Compile an application with R8 using the supplied proguard configuration. */
   protected AndroidApp compileWithR8(List<Class> classes, Path proguardConfig)
-      throws ProguardRuleParserException, ExecutionException, IOException,
-      CompilationFailedException {
+      throws IOException, CompilationFailedException {
     return compileWithR8(readClasses(classes), proguardConfig);
   }
 
-  /**
-   * Compile an application with R8 using the supplied proguard configuration.
-   */
+  /** Compile an application with R8 using the supplied proguard configuration. */
   protected AndroidApp compileWithR8(AndroidApp app, Path proguardConfig)
-      throws ProguardRuleParserException, ExecutionException, IOException,
-      CompilationFailedException {
+      throws IOException, CompilationFailedException {
     R8Command command =
         ToolHelper.prepareR8CommandBuilder(app)
             .addProguardConfigurationFiles(proguardConfig)
@@ -425,36 +389,38 @@
     return ToolHelper.runR8(command);
   }
 
-  /**
-   * Compile an application with R8 using the supplied proguard configuration.
-   */
+  /** Compile an application with R8 using the supplied proguard configuration. */
   protected AndroidApp compileWithR8(AndroidApp app, String proguardConfig)
-      throws ProguardRuleParserException, ExecutionException, IOException,
-      CompilationFailedException {
+      throws IOException, CompilationFailedException {
     return compileWithR8(app, proguardConfig, null);
   }
 
-  /**
-   * Compile an application with R8 using the supplied proguard configuration.
-   */
+  /** Compile an application with R8 using the supplied proguard configuration. */
   protected AndroidApp compileWithR8(
       AndroidApp app, String proguardConfig, Consumer<InternalOptions> optionsConsumer)
-      throws ProguardRuleParserException, ExecutionException, IOException,
-      CompilationFailedException {
+      throws IOException, CompilationFailedException {
+    return compileWithR8(app, proguardConfig, optionsConsumer, Backend.DEX);
+  }
+
+  /** Compile an application with R8 using the supplied proguard configuration and backend. */
+  protected AndroidApp compileWithR8(
+      AndroidApp app,
+      String proguardConfig,
+      Consumer<InternalOptions> optionsConsumer,
+      Backend backend)
+      throws IOException, CompilationFailedException {
     R8Command command =
-        ToolHelper.prepareR8CommandBuilder(app)
+        ToolHelper.prepareR8CommandBuilder(app, emptyConsumer(backend))
             .addProguardConfiguration(ImmutableList.of(proguardConfig), Origin.unknown())
+            .addLibraryFiles(runtimeJar(backend))
             .build();
     return ToolHelper.runR8(command, optionsConsumer);
   }
 
-  /**
-   * Compile an application with R8 using the supplied proguard configuration.
-   */
+  /** Compile an application with R8 using the supplied proguard configuration. */
   protected AndroidApp compileWithR8(
       AndroidApp app, Path proguardConfig, Consumer<InternalOptions> optionsConsumer)
-      throws ProguardRuleParserException, ExecutionException, IOException,
-      CompilationFailedException {
+      throws IOException, CompilationFailedException {
     R8Command command =
         ToolHelper.prepareR8CommandBuilder(app)
             .addProguardConfigurationFiles(proguardConfig)
diff --git a/src/test/java/com/android/tools/r8/debug/DebugTestBase.java b/src/test/java/com/android/tools/r8/debug/DebugTestBase.java
index e9ef5ed..7911016 100644
--- a/src/test/java/com/android/tools/r8/debug/DebugTestBase.java
+++ b/src/test/java/com/android/tools/r8/debug/DebugTestBase.java
@@ -246,6 +246,9 @@
 
           @Override
           public JUnit3Wrapper.DebuggeeState get() {
+            if (wrapper.state == JUnit3Wrapper.State.Exit) {
+              return null;
+            }
             assert verifyStateLocation(wrapper.getDebuggeeState());
             if (initial) {
               if (DEBUG_TESTS) {
diff --git a/src/test/java/com/android/tools/r8/debug/LocalEndTest.java b/src/test/java/com/android/tools/r8/debug/LocalEndTest.java
new file mode 100644
index 0000000..036e590
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/debug/LocalEndTest.java
@@ -0,0 +1,27 @@
+// 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.debug;
+
+public class LocalEndTest {
+
+  public void foo() {
+    {
+      int x = 42;
+      try {
+        bar();
+        x = 7;
+      } catch (Throwable e) {}
+    }
+    int y = 11; // Replaced by stack value of previously visible x (which must not become visible).
+    System.out.println(y);
+  }
+
+  private void bar() {
+    // nothing to do
+  }
+
+  public static void main(String[] args) {
+    new LocalEndTest().foo();
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/debug/LocalEndTestDump.java b/src/test/java/com/android/tools/r8/debug/LocalEndTestDump.java
new file mode 100644
index 0000000..ad6737c
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/debug/LocalEndTestDump.java
@@ -0,0 +1,148 @@
+// 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.debug;
+
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+public class LocalEndTestDump implements Opcodes {
+
+  public static byte[] dump() {
+
+    ClassWriter cw = new ClassWriter(0);
+    MethodVisitor mv;
+
+    cw.visit(
+        V1_8,
+        ACC_PUBLIC + ACC_SUPER,
+        "com/android/tools/r8/debug/LocalEndTest",
+        null,
+        "java/lang/Object",
+        null);
+
+    cw.visitSource("LocalEndTest.java", null);
+
+    {
+      mv = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
+      mv.visitCode();
+      Label l0 = new Label();
+      mv.visitLabel(l0);
+      mv.visitLineNumber(6, l0);
+      mv.visitVarInsn(ALOAD, 0);
+      mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+      mv.visitInsn(RETURN);
+      Label l1 = new Label();
+      mv.visitLabel(l1);
+      mv.visitLocalVariable("this", "Lcom/android/tools/r8/debug/LocalEndTest;", null, l0, l1, 0);
+      mv.visitMaxs(1, 1);
+      mv.visitEnd();
+    }
+    {
+      mv = cw.visitMethod(ACC_PUBLIC, "foo", "()V", null, null);
+      mv.visitCode();
+      Label l0 = new Label();
+      Label l1 = new Label();
+      Label l2 = new Label();
+      mv.visitTryCatchBlock(l0, l1, l2, "java/lang/Throwable");
+      Label l3 = new Label();
+      mv.visitLabel(l3);
+      mv.visitLineNumber(10, l3);
+      mv.visitIntInsn(BIPUSH, 42);
+      mv.visitVarInsn(ISTORE, 1);
+      mv.visitLabel(l0);
+      mv.visitLineNumber(12, l0);
+      mv.visitVarInsn(ILOAD, 1); // push x on the stack for later use in the join block.
+      mv.visitVarInsn(ALOAD, 0);
+      mv.visitMethodInsn(
+          INVOKESPECIAL, "com/android/tools/r8/debug/LocalEndTest", "bar", "()V", false);
+      Label l4 = new Label();
+      mv.visitLabel(l4);
+      mv.visitLineNumber(13, l4);
+      mv.visitIntInsn(BIPUSH, 7);
+      mv.visitVarInsn(ISTORE, 1);
+      mv.visitLabel(l1);
+      mv.visitLineNumber(14, l1);
+      Label l5 = new Label();
+      mv.visitJumpInsn(GOTO, l5);
+      mv.visitLabel(l2);
+      mv.visitFrame(
+          Opcodes.F_FULL,
+          2,
+          new Object[] {"com/android/tools/r8/debug/LocalEndTest", Opcodes.INTEGER},
+          1,
+          new Object[] {"java/lang/Throwable"});
+      mv.visitVarInsn(ASTORE, 2);
+      mv.visitVarInsn(ILOAD, 1); // push x on the stack again (should be same as above).
+      // mv.visitInsn(ICONST_0);
+      mv.visitLabel(l5);
+      mv.visitLineNumber(16, l5);
+      // mv.visitFrame(Opcodes.F_CHOP, 1, null, 0, null);
+      mv.visitFrame(
+          Opcodes.F_FULL,
+          1,
+          new Object[] {"com/android/tools/r8/debug/LocalEndTest"},
+          1,
+          new Object[] {Opcodes.INTEGER});
+      // Load the on-stack copy of x
+      mv.visitVarInsn(ISTORE, 1);
+      Label l6 = new Label();
+      mv.visitLabel(l6);
+      mv.visitLineNumber(17, l6);
+      mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
+      mv.visitVarInsn(ILOAD, 1);
+      mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(I)V", false);
+      Label l7 = new Label();
+      mv.visitLabel(l7);
+      mv.visitLineNumber(18, l7);
+      mv.visitInsn(RETURN);
+      Label l8 = new Label();
+      mv.visitLabel(l8);
+      mv.visitLocalVariable("x", "I", null, l0, l5, 1);
+      mv.visitLocalVariable("this", "Lcom/android/tools/r8/debug/LocalEndTest;", null, l3, l8, 0);
+      mv.visitLocalVariable("y", "I", null, l6, l8, 1);
+      mv.visitMaxs(2, 3);
+      mv.visitEnd();
+    }
+    {
+      mv = cw.visitMethod(ACC_PRIVATE, "bar", "()V", null, null);
+      mv.visitCode();
+      Label l0 = new Label();
+      mv.visitLabel(l0);
+      mv.visitLineNumber(22, l0);
+      mv.visitInsn(RETURN);
+      Label l1 = new Label();
+      mv.visitLabel(l1);
+      mv.visitLocalVariable("this", "Lcom/android/tools/r8/debug/LocalEndTest;", null, l0, l1, 0);
+      mv.visitMaxs(0, 1);
+      mv.visitEnd();
+    }
+    {
+      mv = cw.visitMethod(ACC_PUBLIC + ACC_STATIC, "main", "([Ljava/lang/String;)V", null, null);
+      mv.visitCode();
+      Label l0 = new Label();
+      mv.visitLabel(l0);
+      mv.visitLineNumber(25, l0);
+      mv.visitTypeInsn(NEW, "com/android/tools/r8/debug/LocalEndTest");
+      mv.visitInsn(DUP);
+      mv.visitMethodInsn(
+          INVOKESPECIAL, "com/android/tools/r8/debug/LocalEndTest", "<init>", "()V", false);
+      mv.visitMethodInsn(
+          INVOKEVIRTUAL, "com/android/tools/r8/debug/LocalEndTest", "foo", "()V", false);
+      Label l1 = new Label();
+      mv.visitLabel(l1);
+      mv.visitLineNumber(26, l1);
+      mv.visitInsn(RETURN);
+      Label l2 = new Label();
+      mv.visitLabel(l2);
+      mv.visitLocalVariable("args", "[Ljava/lang/String;", null, l0, l2, 0);
+      mv.visitMaxs(2, 1);
+      mv.visitEnd();
+    }
+    cw.visitEnd();
+
+    return cw.toByteArray();
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/debug/LocalEndTestRunner.java b/src/test/java/com/android/tools/r8/debug/LocalEndTestRunner.java
new file mode 100644
index 0000000..982332e
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/debug/LocalEndTestRunner.java
@@ -0,0 +1,71 @@
+// 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.debug;
+
+import com.android.tools.r8.ClassFileConsumer;
+import com.android.tools.r8.ClassFileConsumer.ArchiveConsumer;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.google.common.collect.ImmutableList;
+import java.nio.file.Path;
+import java.util.Collection;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class LocalEndTestRunner extends DebugTestBase {
+
+  static final Class CLASS = LocalEndTest.class;
+  static final String NAME = CLASS.getCanonicalName();
+  static final String DESC = DescriptorUtils.javaTypeToDescriptor(NAME);
+  static final String FILE = CLASS.getSimpleName() + ".java";
+
+  private static Path inputJarCache = null;
+
+  private final String name;
+  private final DebugTestConfig config;
+
+  @Parameters(name = "{0}")
+  public static Collection<Object[]> setup() {
+    DelayedDebugTestConfig cf = temp -> new CfDebugTestConfig().addPaths(getInputJar(temp));
+    DelayedDebugTestConfig d8 =
+        temp -> new D8DebugTestConfig().compileAndAdd(temp, getInputJar(temp));
+    return ImmutableList.of(new Object[] {"CF", cf}, new Object[] {"D8", d8});
+  }
+
+  private static Path getInputJar(TemporaryFolder temp) {
+    if (inputJarCache == null) {
+      inputJarCache = temp.getRoot().toPath().resolve("input.jar");
+      ClassFileConsumer jarWriter = new ArchiveConsumer(inputJarCache);
+      jarWriter.accept(LocalEndTestDump.dump(), DESC, null);
+      jarWriter.finished(null);
+    }
+    return inputJarCache;
+  }
+
+  public LocalEndTestRunner(String name, DelayedDebugTestConfig config) {
+    this.name = name;
+    this.config = config.getConfig(temp);
+  }
+
+  @Test
+  public void test() throws Throwable {
+    runDebugTest(
+        config,
+        NAME,
+        breakpoint(NAME, "foo", 13),
+        run(),
+        checkLine(FILE, 13),
+        checkLocal("x"),
+        stepOver(),
+        checkLine(FILE, 14),
+        checkLocal("x"),
+        stepOver(),
+        checkLine(FILE, 16),
+        checkNoLocal("x"),
+        run());
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/debug/PostIncrementTest.java b/src/test/java/com/android/tools/r8/debug/PostIncrementTest.java
new file mode 100644
index 0000000..543a5a1
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/debug/PostIncrementTest.java
@@ -0,0 +1,23 @@
+// 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.debug;
+
+public class PostIncrementTest {
+
+  static final int LENGTH = 4 * 16;
+
+  private static void loop(int[] a) {
+    int i = 0;
+    int s = 128;
+    while (i++ < LENGTH - 2) {
+      if (i % 2 == 0) {
+        a[i] = s++;
+      }
+    }
+  }
+
+  public static void main(String[] args) {
+    loop(new int[LENGTH]);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/debug/PostIncrementTestRunner.java b/src/test/java/com/android/tools/r8/debug/PostIncrementTestRunner.java
new file mode 100644
index 0000000..4cfb71a
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/debug/PostIncrementTestRunner.java
@@ -0,0 +1,34 @@
+// 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.debug;
+
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.DexVm;
+import com.android.tools.r8.debug.DebugTestBase.JUnit3Wrapper.DebuggeeState;
+import java.util.stream.Stream;
+import org.junit.Assume;
+import org.junit.Test;
+
+// See b/80385846
+public class PostIncrementTestRunner extends DebugTestBase {
+
+  private static final Class CLASS = PostIncrementTest.class;
+  private static final String NAME = CLASS.getCanonicalName();
+
+  @Test
+  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));
+    DebugTestConfig cfConfig = new CfDebugTestConfig().addPaths(ToolHelper.getClassPathForTests());
+    DebugTestConfig d8Config = new D8DebugTestConfig().compileAndAddClasses(temp, CLASS);
+    new DebugStreamComparator()
+        .add("CF", createStream(cfConfig))
+        .add("D8", createStream(d8Config))
+        .compare();
+  }
+
+  private Stream<DebuggeeState> createStream(DebugTestConfig config) throws Exception {
+    return streamDebugTest(config, NAME, ANDROID_FILTER);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/debug/SynchronizedBlockTest.java b/src/test/java/com/android/tools/r8/debug/SynchronizedBlockTest.java
index a23f3f4..17f0c04 100644
--- a/src/test/java/com/android/tools/r8/debug/SynchronizedBlockTest.java
+++ b/src/test/java/com/android/tools/r8/debug/SynchronizedBlockTest.java
@@ -5,25 +5,61 @@
 
 import static org.hamcrest.core.IsNot.not;
 
+import com.android.tools.r8.CompilationMode;
+import com.android.tools.r8.OutputMode;
+import com.android.tools.r8.R8Command;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.ToolHelper.DexVm;
+import com.google.common.collect.ImmutableList;
+import java.nio.file.Path;
+import java.util.Collection;
 import org.junit.Assume;
-import org.junit.BeforeClass;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
 
-/**
- * Test single stepping behaviour of synchronized blocks.
- */
+/** Test single stepping behaviour of synchronized blocks. */
+@RunWith(Parameterized.class)
 public class SynchronizedBlockTest extends DebugTestBase {
 
   public static final String CLASS = "SynchronizedBlock";
   public static final String FILE = "SynchronizedBlock.java";
 
-  private static DebugTestConfig config;
+  private final String name;
+  private final DebugTestConfig config;
 
-  @BeforeClass
-  public static void setup() {
-    config = new D8DebugTestResourcesConfig(temp);
+  @Parameterized.Parameters(name = "{0}")
+  public static Collection<Object[]> setup() {
+    DelayedDebugTestConfig cf =
+        temp -> new CfDebugTestConfig().addPaths(DebugTestBase.DEBUGGEE_JAR);
+    DelayedDebugTestConfig r8cf = temp -> new R8CfDebugTestResourcesConfig(temp);
+    DelayedDebugTestConfig r8cfcf =
+        temp -> {
+          Path out = temp.getRoot().toPath().resolve("r8cfcf.jar");
+          try {
+            ToolHelper.runR8(
+                R8Command.builder()
+                    .setOutput(out, OutputMode.ClassFile)
+                    .setMode(CompilationMode.DEBUG)
+                    .addProgramFiles(DebugTestBase.DEBUGGEE_JAR)
+                    .build(),
+                options -> options.enableCfFrontend = true);
+          } catch (Exception e) {
+            throw new RuntimeException(e);
+          }
+          return new CfDebugTestConfig().addPaths(out);
+        };
+    DelayedDebugTestConfig d8 = temp -> new D8DebugTestResourcesConfig(temp);
+    return ImmutableList.of(
+        new Object[] {"CF", cf},
+        new Object[] {"D8", d8},
+        new Object[] {"R8/CF", r8cf},
+        new Object[] {"R8/CF/CF", r8cfcf});
+  }
+
+  public SynchronizedBlockTest(String name, DelayedDebugTestConfig config) {
+    this.name = name;
+    this.config = config.getConfig(temp);
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/maindexlist/MainDexListTests.java b/src/test/java/com/android/tools/r8/maindexlist/MainDexListTests.java
index d56c0e7..a148a26 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/MainDexListTests.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/MainDexListTests.java
@@ -753,6 +753,12 @@
     }
 
     @Override
+    public void buildBlockTransfer(
+        IRBuilder builder, int predecessorOffset, int successorOffset, boolean isExceptional) {
+      throw new Unreachable();
+    }
+
+    @Override
     public void buildPostlude(IRBuilder builder) {
       // Intentionally empty.
     }
diff --git a/src/test/java/com/android/tools/r8/naming/CovariantReturnTypeInSubInterfaceTest.java b/src/test/java/com/android/tools/r8/naming/CovariantReturnTypeInSubInterfaceTest.java
new file mode 100644
index 0000000..6602d0c
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/naming/CovariantReturnTypeInSubInterfaceTest.java
@@ -0,0 +1,106 @@
+// 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.naming;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.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.util.List;
+import org.junit.Ignore;
+import org.junit.Test;
+
+interface SuperInterface {
+  Super foo();
+}
+
+interface SubInterface extends SuperInterface {
+  @Override
+  Sub foo();
+}
+
+class Super {
+  protected int bar() {
+    return 0;
+  }
+}
+
+class Sub extends Super {
+  @Override
+  protected int bar() {
+    return 1;
+  }
+}
+
+class SuperImplementer implements SuperInterface {
+  @Override
+  public Super foo() {
+    return new Super();
+  }
+}
+
+class SubImplementer implements SubInterface {
+  @Override
+  public Sub foo() {
+    return new Sub();
+  }
+}
+
+class TestMain {
+  public static void main(String[] args) {
+    SubImplementer subImplementer = new SubImplementer();
+    Super sup = subImplementer.foo();
+    System.out.println(sup.bar());
+  }
+}
+
+public class CovariantReturnTypeInSubInterfaceTest extends TestBase {
+
+  @Ignore("b/112185748")
+  @Test
+  public void test() throws Exception {
+    List<String> config = ImmutableList.of(
+        "-printmapping",
+        "-useuniqueclassmembernames",
+        "-keep class " + TestMain.class.getCanonicalName() + " {",
+        "  public void main(...);",
+        "}",
+        "-keep,allowobfuscation class **.Super* {",
+        "  <methods>;",
+        "}",
+        "-keep,allowobfuscation class **.Sub* {",
+        "  <methods>;",
+        "}"
+    );
+    AndroidApp app = readClasses(
+        SuperInterface.class,
+        SubInterface.class,
+        Super.class,
+        Sub.class,
+        SuperImplementer.class,
+        SubImplementer.class,
+        TestMain.class
+    );
+    AndroidApp processedApp = compileWithR8(app, String.join(System.lineSeparator(), config));
+    CodeInspector inspector = new CodeInspector(processedApp);
+    ClassSubject superInterface = inspector.clazz(SuperInterface.class);
+    assertThat(superInterface, isRenamed());
+    MethodSubject foo1 = superInterface.method(
+        Super.class.getCanonicalName(), "foo", ImmutableList.of());
+    assertThat(foo1, isRenamed());
+    ClassSubject subInterface = inspector.clazz(SubInterface.class);
+    assertThat(subInterface, isRenamed());
+    MethodSubject foo2 = subInterface.method(
+        Sub.class.getCanonicalName(), "foo", ImmutableList.of());
+    assertThat(foo2, isRenamed());
+    assertEquals(foo1.getFinalName(), foo2.getFinalName());
+  }
+
+}
diff --git a/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/ForceProguardCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/ForceProguardCompatibilityTest.java
index 9cf0a85..ff762b7 100644
--- a/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/ForceProguardCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/ForceProguardCompatibilityTest.java
@@ -9,7 +9,6 @@
 import static org.junit.Assert.assertTrue;
 
 import com.android.tools.r8.CompatProguardCommandBuilder;
-import com.android.tools.r8.DexIndexedConsumer;
 import com.android.tools.r8.R8Command;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.ToolHelper;
@@ -42,24 +41,42 @@
 import com.android.tools.r8.utils.codeinspector.FieldSubject;
 import com.android.tools.r8.utils.codeinspector.MethodSubject;
 import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Iterables;
 import it.unimi.dsi.fastutil.objects.Object2BooleanArrayMap;
 import it.unimi.dsi.fastutil.objects.Object2BooleanMap;
 import java.io.File;
 import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
 
+@RunWith(Parameterized.class)
 public class ForceProguardCompatibilityTest extends TestBase {
+
+  private Backend backend;
+
+  @Parameterized.Parameters(name = "Backend: {0}")
+  public static Collection<Backend> data() {
+    return Arrays.asList(Backend.values());
+  }
+
+  public ForceProguardCompatibilityTest(Backend backend) {
+    this.backend = backend;
+  }
+
   private void test(Class mainClass, Class mentionedClass, boolean forceProguardCompatibility)
       throws Exception {
     String proguardConfig = keepMainProguardConfiguration(mainClass, true, false);
-    CodeInspector inspector = new CodeInspector(
-        compileWithR8(
-            ImmutableList.of(mainClass, mentionedClass),
-            proguardConfig,
-            options -> options.forceProguardCompatibility = forceProguardCompatibility));
+    CodeInspector inspector =
+        new CodeInspector(
+            compileWithR8(
+                readClasses(ImmutableList.of(mainClass, mentionedClass)),
+                proguardConfig,
+                options -> options.forceProguardCompatibility = forceProguardCompatibility,
+                backend));
     assertTrue(inspector.clazz(mainClass.getCanonicalName()).isPresent());
     ClassSubject clazz = inspector.clazz(getJavacGeneratedClassName(mentionedClass));
     assertTrue(clazz.isPresent());
@@ -101,7 +118,7 @@
           Origin.unknown());
     }
 
-    builder.setProgramConsumer(DexIndexedConsumer.emptyConsumer());
+    builder.setProgramConsumer(emptyConsumer(backend)).addLibraryFiles(runtimeJar(backend));
     CodeInspector inspector = new CodeInspector(ToolHelper.runR8(builder.build()));
     assertTrue(inspector.clazz(mainClass.getCanonicalName()).isPresent());
     ClassSubject clazz = inspector.clazz(getJavacGeneratedClassName(mentionedClassWithAnnotations));
@@ -136,7 +153,7 @@
     Path proguardCompatibilityRules = temp.newFile().toPath();
     builder.setProguardCompatibilityRulesOutput(proguardCompatibilityRules);
 
-    builder.setProgramConsumer(DexIndexedConsumer.emptyConsumer());
+    builder.setProgramConsumer(emptyConsumer(backend)).addLibraryFiles(runtimeJar(backend));
     CodeInspector inspector = new CodeInspector(ToolHelper.runR8(builder.build()));
     ClassSubject clazz = inspector.clazz(getJavacGeneratedClassName(testClass));
     assertTrue(clazz.isPresent());
@@ -193,7 +210,7 @@
         "-dontobfuscate");
     builder.addProguardConfiguration(proguardConfig, Origin.unknown());
 
-    builder.setProgramConsumer(DexIndexedConsumer.emptyConsumer());
+    builder.setProgramConsumer(emptyConsumer(backend)).addLibraryFiles(runtimeJar(backend));
     CodeInspector inspector = new CodeInspector(ToolHelper.runR8(builder.build()));
     assertTrue(inspector.clazz(getJavacGeneratedClassName(mainClass)).isPresent());
     ClassSubject clazz = inspector.clazz(getJavacGeneratedClassName(instantiatedClass));
@@ -255,7 +272,7 @@
       builder.setProguardMapOutputPath(temp.newFile().toPath());
     }
 
-    builder.setProgramConsumer(DexIndexedConsumer.emptyConsumer());
+    builder.setProgramConsumer(emptyConsumer(backend)).addLibraryFiles(runtimeJar(backend));
     CodeInspector inspector = new CodeInspector(ToolHelper.runR8(builder.build()));
     assertTrue(inspector.clazz(getJavacGeneratedClassName(mainClass)).isPresent());
     forNameClasses.forEach(clazz -> {
@@ -349,7 +366,7 @@
       builder.setProguardMapOutputPath(temp.newFile().toPath());
     }
 
-    builder.setProgramConsumer(DexIndexedConsumer.emptyConsumer());
+    builder.setProgramConsumer(emptyConsumer(backend)).addLibraryFiles(runtimeJar(backend));
     CodeInspector inspector = new CodeInspector(ToolHelper.runR8(builder.build()));
     assertTrue(inspector.clazz(getJavacGeneratedClassName(mainClass)).isPresent());
     ClassSubject classSubject = inspector.clazz(getJavacGeneratedClassName(withMemberClass));
@@ -453,7 +470,7 @@
       builder.setProguardMapOutputPath(temp.newFile().toPath());
     }
 
-    builder.setProgramConsumer(DexIndexedConsumer.emptyConsumer());
+    builder.setProgramConsumer(emptyConsumer(backend)).addLibraryFiles(runtimeJar(backend));
     CodeInspector inspector = new CodeInspector(ToolHelper.runR8(builder.build()));
     assertTrue(inspector.clazz(getJavacGeneratedClassName(mainClass)).isPresent());
     ClassSubject classSubject = inspector.clazz(getJavacGeneratedClassName(withVolatileFields));
@@ -568,7 +585,7 @@
     builder.setProguardCompatibilityRulesOutput(proguardCompatibilityRules);
 
     AndroidApp app;
-    builder.setProgramConsumer(DexIndexedConsumer.emptyConsumer());
+    builder.setProgramConsumer(emptyConsumer(backend)).addLibraryFiles(runtimeJar(backend));
     try {
       app = ToolHelper.runR8(builder.build(), o -> o.enableClassInlining = false);
     } catch (CompilationError e) {
@@ -577,7 +594,14 @@
     }
     CodeInspector inspector = new CodeInspector(app);
     assertTrue(inspector.clazz(getJavacGeneratedClassName(mainClass)).isPresent());
-    assertEquals(innerClasses || enclosingMethod ? "1" : "0", runOnArt(app, mainClass));
+    String result;
+    if (backend == Backend.DEX) {
+      result = runOnArt(app, mainClass);
+    } else {
+      assert backend == Backend.CF;
+      result = runOnJava(app, mainClass);
+    }
+    assertEquals(innerClasses || enclosingMethod ? "1" : "0", result);
 
     // Check the Proguard compatibility configuration generated.
     ProguardConfigurationParser parser =
@@ -623,8 +647,10 @@
         "-dontobfuscate"),
         Origin.unknown());
     builder.addProguardConfiguration(additionalKeepRules, Origin.unknown());
-    builder.setProgramConsumer(DexIndexedConsumer.emptyConsumer());
-    builder.setMinApiLevel(AndroidApiLevel.O.getLevel());
+    builder.setProgramConsumer(emptyConsumer(backend)).addLibraryFiles(runtimeJar(backend));
+    if (backend == Backend.DEX) {
+      builder.setMinApiLevel(AndroidApiLevel.O.getLevel());
+    }
     Path proguardCompatibilityRules = temp.newFile().toPath();
     builder.setProguardCompatibilityRulesOutput(proguardCompatibilityRules);
     AndroidApp app = ToolHelper.runR8(builder.build(), o -> o.enableClassInlining = false);
diff --git a/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/ProguardCompatibilityTestBase.java b/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/ProguardCompatibilityTestBase.java
index f10395e..3e25aec 100644
--- a/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/ProguardCompatibilityTestBase.java
+++ b/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/ProguardCompatibilityTestBase.java
@@ -51,8 +51,9 @@
   }
 
   protected AndroidApp runShrinker(
-      Shrinker mode, List<Class> programClasses, Iterable<String> proguadConfigs) throws Exception {
-    return runShrinker(mode, programClasses, String.join(System.lineSeparator(), proguadConfigs));
+      Shrinker mode, List<Class> programClasses, Iterable<String> proguardConfigs)
+      throws Exception {
+    return runShrinker(mode, programClasses, String.join(System.lineSeparator(), proguardConfigs));
   }
 
   protected AndroidApp runShrinker(Shrinker mode, List<Class> programClasses, String proguardConfig)
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/IfOnAnnotationTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/IfOnAnnotationTest.java
index 20363c5..b67d2a2 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/IfOnAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/IfOnAnnotationTest.java
@@ -28,7 +28,7 @@
 
   @Parameters(name = "shrinker: {0}")
   public static Collection<Object> data() {
-    return ImmutableList.of(Shrinker.PROGUARD6, Shrinker.R8);
+    return ImmutableList.of(Shrinker.PROGUARD6, Shrinker.R8, Shrinker.R8_CF);
   }
 
   @Test
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/IfOnClassTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/IfOnClassTest.java
index 906788a..5893782 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/IfOnClassTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/IfOnClassTest.java
@@ -41,11 +41,12 @@
   @Parameters(name = "shrinker: {0} precondition: {1}")
   public static Collection<Object[]> data() {
     return ImmutableList.of(
-        new Object[]{Shrinker.PROGUARD6, true},
-        new Object[]{Shrinker.PROGUARD6, false},
-        new Object[]{Shrinker.R8, true},
-        new Object[]{Shrinker.R8, false}
-    );
+        new Object[] {Shrinker.PROGUARD6, true},
+        new Object[] {Shrinker.PROGUARD6, false},
+        new Object[] {Shrinker.R8, true},
+        new Object[] {Shrinker.R8, false},
+        new Object[] {Shrinker.R8_CF, true},
+        new Object[] {Shrinker.R8_CF, false});
   }
 
   private String adaptConfiguration(String proguardConfig) {
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/IfOnFieldTest.java b/src/test/java/com/android/tools/r8/shaking/ifrule/IfOnFieldTest.java
index 79c132b..25acb23 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/IfOnFieldTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/IfOnFieldTest.java
@@ -31,7 +31,7 @@
 
   @Parameters(name = "shrinker: {0}")
   public static Collection<Object> data() {
-    return ImmutableList.of(Shrinker.PROGUARD6, Shrinker.R8);
+    return ImmutableList.of(Shrinker.PROGUARD6, Shrinker.R8, Shrinker.R8_CF);
   }
 
   private String adaptConfiguration(String proguardConfig) {
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 fb9ce61..4081836 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
@@ -8,12 +8,16 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertThat;
 
+import com.android.tools.r8.OutputMode;
+import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.ToolHelper.ProcessResult;
 import com.android.tools.r8.shaking.forceproguardcompatibility.ProguardCompatibilityTestBase;
 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.google.common.collect.ImmutableList;
+import java.io.File;
+import java.nio.file.Path;
 import java.util.Collection;
 import java.util.List;
 import org.junit.Test;
@@ -58,10 +62,12 @@
   @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, true},
+        new Object[] {Shrinker.R8, false},
+        new Object[] {Shrinker.R8_CF, false});
   }
 
   private void check(AndroidApp app) throws Exception {
@@ -72,7 +78,15 @@
     assertEquals(!inlineMethod, clazzA.method("int", "a", ImmutableList.of()).isPresent());
     // TODO(110148109): class D should be present - inlining or not.
     assertEquals(!inlineMethod, inspector.clazz(D.class).isPresent());
-    ProcessResult result = runOnArtRaw(app, Main.class.getName());
+    ProcessResult result;
+    if (shrinker == Shrinker.R8) {
+      result = runOnArtRaw(app, Main.class.getName());
+    } else {
+      assert shrinker == Shrinker.R8_CF;
+      Path file = File.createTempFile("junit", ".zip", temp.getRoot()).toPath();
+      app.writeToZip(file, OutputMode.ClassFile);
+      result = ToolHelper.runJava(file, Main.class.getName());
+    }
     assertEquals(0, result.exitCode);
     // TODO(110148109): Output should be the same - inlining or not.
     assertEquals(!inlineMethod ? "1" : "2", result.stdout);
diff --git a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/IfRuleWithVerticalClassMerging.java b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/IfRuleWithVerticalClassMerging.java
index 1cec850..8bc82db 100644
--- a/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/IfRuleWithVerticalClassMerging.java
+++ b/src/test/java/com/android/tools/r8/shaking/ifrule/verticalclassmerging/IfRuleWithVerticalClassMerging.java
@@ -8,6 +8,8 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertThat;
 
+import com.android.tools.r8.OutputMode;
+import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.ToolHelper.ProcessResult;
 import com.android.tools.r8.shaking.forceproguardcompatibility.ProguardCompatibilityTestBase;
 import com.android.tools.r8.utils.AndroidApp;
@@ -15,6 +17,8 @@
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.google.common.collect.ImmutableList;
+import java.io.File;
+import java.nio.file.Path;
 import java.util.Collection;
 import java.util.List;
 import org.junit.Test;
@@ -74,9 +78,10 @@
   public static Collection<Object[]> data() {
     // We don't run this on Proguard, as Proguard does not merge A into B.
     return ImmutableList.of(
-        new Object[]{Shrinker.R8, true},
-        new Object[]{Shrinker.R8, false}
-    );
+        new Object[] {Shrinker.R8, true},
+        new Object[] {Shrinker.R8, false},
+        new Object[] {Shrinker.R8_CF, true},
+        new Object[] {Shrinker.R8_CF, false});
   }
 
   private void configure(InternalOptions options) {
@@ -99,7 +104,15 @@
     // TODO(110141157): Class D should be kept - vertical class merging or not.
     assertEquals(!enableClassMerging, clazzD.isPresent());
 
-    ProcessResult result = runOnArtRaw(app, Main.class.getName());
+    ProcessResult result;
+    if (shrinker == Shrinker.R8) {
+      result = runOnArtRaw(app, Main.class.getName());
+    } else {
+      assert shrinker == Shrinker.R8_CF;
+      Path file = File.createTempFile("junit", ".zip", temp.getRoot()).toPath();
+      app.writeToZip(file, OutputMode.ClassFile);
+      result = ToolHelper.runJava(file, Main.class.getName());
+    }
     // TODO(110141157): The code should run - vertical class merging or not.
     assertEquals(enableClassMerging ? 1 : 0, result.exitCode);
     if (!enableClassMerging) {
diff --git a/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepClassMembersTest.java b/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepClassMembersTest.java
index cff0675..0b6176b 100644
--- a/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepClassMembersTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/keepclassmembers/KeepClassMembersTest.java
@@ -17,10 +17,26 @@
 import com.android.tools.r8.utils.codeinspector.FieldSubject;
 import com.android.tools.r8.utils.codeinspector.MethodSubject;
 import com.google.common.collect.ImmutableList;
+import java.util.Arrays;
+import java.util.Collection;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
 
+@RunWith(Parameterized.class)
 public class KeepClassMembersTest extends ProguardCompatibilityTestBase {
 
+  private Backend backend;
+
+  @Parameterized.Parameters(name = "Backend: {0}")
+  public static Collection<Backend> data() {
+    return Arrays.asList(Backend.values());
+  }
+
+  public KeepClassMembersTest(Backend backend) {
+    this.backend = backend;
+  }
+
   private void check(CodeInspector inspector, Class mainClass, Class<?> staticClass,
       boolean forceProguardCompatibility, boolean fromProguard) {
     assertTrue(inspector.clazz(mainClass).isPresent());
@@ -71,9 +87,13 @@
         "-dontoptimize", "-dontobfuscate"
     ));
     CodeInspector inspector;
-      inspector = new CodeInspector(
-          compileWithR8(ImmutableList.of(mainClass, staticClass), proguardConfig,
-              options -> options.forceProguardCompatibility = forceProguardCompatibility));
+    inspector =
+        new CodeInspector(
+            compileWithR8(
+                readClasses(ImmutableList.of(mainClass, staticClass)),
+                proguardConfig,
+                options -> options.forceProguardCompatibility = forceProguardCompatibility,
+                backend));
     check(inspector, mainClass, staticClass, forceProguardCompatibility, false);
 
     if (isRunProguard()) {