diff --git a/build.gradle b/build.gradle
index b733b88..dd401d6 100644
--- a/build.gradle
+++ b/build.gradle
@@ -517,6 +517,7 @@
 task repackageDeps(type: ShadowJar) {
     configurations = [project.configurations.compile]
     configureRelocations(it)
+    exclude { it.getRelativePath().getPathString() == "module-info.class" }
     baseName 'deps'
 }
 
diff --git a/src/main/java/com/android/tools/r8/Version.java b/src/main/java/com/android/tools/r8/Version.java
index 63c1173..b7fc6b3 100644
--- a/src/main/java/com/android/tools/r8/Version.java
+++ b/src/main/java/com/android/tools/r8/Version.java
@@ -11,7 +11,7 @@
 
   // This field is accessed from release scripts using simple pattern matching.
   // Therefore, changing this field could break our release scripts.
-  public static final String LABEL = "1.3.5-dev";
+  public static final String LABEL = "1.3.7-dev";
 
   private Version() {
   }
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 7508ea0..644f2c2 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
@@ -35,6 +35,10 @@
     return position;
   }
 
+  public CfLabel getLabel() {
+    return label;
+  }
+
   @Override
   public void buildIR(IRBuilder builder, CfState state, CfSourceCode code) {
     state.setPosition(position);
diff --git a/src/main/java/com/android/tools/r8/ir/code/BasicBlock.java b/src/main/java/com/android/tools/r8/ir/code/BasicBlock.java
index 5bed061..8ab2c1a 100644
--- a/src/main/java/com/android/tools/r8/ir/code/BasicBlock.java
+++ b/src/main/java/com/android/tools/r8/ir/code/BasicBlock.java
@@ -6,6 +6,7 @@
 import static com.android.tools.r8.ir.code.IRCode.INSTRUCTION_NUMBER_DELTA;
 
 import com.android.tools.r8.errors.CompilationError;
+import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.DebugLocalInfo;
 import com.android.tools.r8.graph.DebugLocalInfo.PrintLevel;
 import com.android.tools.r8.graph.DexItemFactory;
@@ -467,7 +468,7 @@
         return instruction;
       }
     }
-    return null;
+    throw new Unreachable();
   }
 
   public void clearUserInfo() {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/CfBuilder.java b/src/main/java/com/android/tools/r8/ir/conversion/CfBuilder.java
index 00a94a9..f276cb2 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/CfBuilder.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/CfBuilder.java
@@ -87,6 +87,8 @@
   private List<InvokeDirect> thisInitializers;
   private Map<NewInstance, CfLabel> newInstanceLabels;
 
+  private InternalOptions options;
+
   // Internal abstraction of the stack values and height.
   private static class Stack {
     int maxHeight = 0;
@@ -123,6 +125,7 @@
       GraphLense graphLense,
       InternalOptions options,
       AppInfoWithSubtyping appInfo) {
+    this.options = options;
     computeInitializers();
     types = new TypeVerificationHelper(code, factory, appInfo).computeVerificationTypes();
     splitExceptionalBlocks();
@@ -379,7 +382,10 @@
   private void updatePositionAndLocals(Instruction instruction) {
     Position position = instruction.getPosition();
     boolean didLocalsChange = localsChanged();
-    boolean didPositionChange = position.isSome() && position != currentPosition;
+    boolean didPositionChange =
+        position.isSome()
+            && position != currentPosition
+            && (options.debug || instruction.instructionTypeCanThrow());
     if (!didLocalsChange && !didPositionChange) {
       return;
     }
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
index fffbc44..c6ba97d 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
@@ -46,7 +46,6 @@
 import com.android.tools.r8.ir.optimize.NonNullTracker;
 import com.android.tools.r8.ir.optimize.Outliner;
 import com.android.tools.r8.ir.optimize.PeepholeOptimizer;
-import com.android.tools.r8.ir.optimize.RedundantFieldLoadElimination;
 import com.android.tools.r8.ir.optimize.classinliner.ClassInliner;
 import com.android.tools.r8.ir.optimize.lambda.LambdaMerger;
 import com.android.tools.r8.ir.regalloc.LinearScanRegisterAllocator;
@@ -696,7 +695,6 @@
     codeRewriter.rewriteSwitch(code);
     codeRewriter.processMethodsNeverReturningNormally(code);
     codeRewriter.simplifyIf(code, typeEnvironment);
-    new RedundantFieldLoadElimination(code).run();
 
     if (options.testing.invertConditionals) {
       invertConditionalsForTesting(code);
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/RedundantFieldLoadElimination.java b/src/main/java/com/android/tools/r8/ir/optimize/RedundantFieldLoadElimination.java
deleted file mode 100644
index 24012b1..0000000
--- a/src/main/java/com/android/tools/r8/ir/optimize/RedundantFieldLoadElimination.java
+++ /dev/null
@@ -1,193 +0,0 @@
-// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.optimize;
-
-import com.android.tools.r8.graph.DexField;
-import com.android.tools.r8.ir.code.BasicBlock;
-import com.android.tools.r8.ir.code.DominatorTree;
-import com.android.tools.r8.ir.code.FieldInstruction;
-import com.android.tools.r8.ir.code.IRCode;
-import com.android.tools.r8.ir.code.Instruction;
-import com.android.tools.r8.ir.code.InstructionListIterator;
-import com.android.tools.r8.ir.code.Phi;
-import com.android.tools.r8.ir.code.Value;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-
-/**
- * Eliminate redundant field loads.
- *
- * <p>Simple algorithm that goes through all blocks in one pass in dominator order and propagates
- * active field sets across control-flow edges where the target has only one predecessor.
- */
-// TODO(ager): Evaluate speed/size for computing active field sets in a fixed-point computation.
-public class RedundantFieldLoadElimination {
-
-  private final IRCode code;
-  private final DominatorTree dominatorTree;
-
-  // Maps keeping track of fields that have an already loaded value at basic block entry.
-  private final HashMap<BasicBlock, HashMap<FieldAndObject, Instruction>>
-      activeInstanceFieldsAtEntry = new HashMap<>();
-  private final HashMap<BasicBlock, HashMap<DexField, Instruction>> activeStaticFieldsAtEntry =
-      new HashMap<>();
-
-  // Maps keeping track of fields with already loaded values for the current block during
-  // elimination.
-  private HashMap<FieldAndObject, Instruction> activeInstanceFields;
-  private HashMap<DexField, Instruction> activeStaticFields;
-
-  public RedundantFieldLoadElimination(IRCode code) {
-    this.code = code;
-    dominatorTree = new DominatorTree(code);
-  }
-
-  private static class FieldAndObject {
-    private final DexField field;
-    private final Value object;
-
-    private FieldAndObject(DexField field, Value receiver) {
-      this.field = field;
-      this.object = receiver;
-    }
-
-    @Override
-    public int hashCode() {
-      return field.hashCode() * 7 + object.hashCode();
-    }
-
-    @Override
-    public boolean equals(Object other) {
-      if (!(other instanceof FieldAndObject)) {
-        return false;
-      }
-      FieldAndObject o = (FieldAndObject) other;
-      return o.object == object && o.field == field;
-    }
-  }
-
-  public void run() {
-    for (BasicBlock block : dominatorTree.getSortedBlocks()) {
-      activeInstanceFields =
-          activeInstanceFieldsAtEntry.containsKey(block)
-              ? activeInstanceFieldsAtEntry.get(block)
-              : new HashMap<>();
-      activeStaticFields =
-          activeStaticFieldsAtEntry.containsKey(block)
-              ? activeStaticFieldsAtEntry.get(block)
-              : new HashMap<>();
-      InstructionListIterator it = block.listIterator();
-      while (it.hasNext()) {
-        Instruction instruction = it.next();
-        if (instruction.isFieldInstruction()) {
-          DexField field = instruction.asFieldInstruction().getField();
-          if (instruction.isInstancePut() || instruction.isStaticPut()) {
-            killActiveFields(instruction.asFieldInstruction());
-          } else if (instruction.isInstanceGet() && !instruction.outValue().hasLocalInfo()) {
-            Value object = instruction.asInstanceGet().object();
-            FieldAndObject fieldAndObject = new FieldAndObject(field, object);
-            if (activeInstanceFields.containsKey(fieldAndObject)) {
-              Instruction active = activeInstanceFields.get(fieldAndObject);
-              eliminateRedundantRead(it, instruction, active);
-            } else {
-              activeInstanceFields.put(fieldAndObject, instruction);
-            }
-          } else if (instruction.isStaticGet() && !instruction.outValue().hasLocalInfo()) {
-            if (activeStaticFields.containsKey(field)) {
-              Instruction active = activeStaticFields.get(field);
-              eliminateRedundantRead(it, instruction, active);
-            } else {
-              // A field get on a different class can cause <clinit> to run and change static
-              // field values.
-              killActiveFields(instruction.asFieldInstruction());
-              activeStaticFields.put(field, instruction);
-            }
-          }
-        }
-        if (instruction.isMonitor() || instruction.isInvokeMethod()) {
-          activeInstanceFields.clear();
-          activeStaticFields.clear();
-        }
-      }
-      propagateActiveFieldsFrom(block);
-    }
-    assert code.isConsistentSSA();
-  }
-
-  private void propagateActiveFieldsFrom(BasicBlock block) {
-    for (BasicBlock successor : block.getSuccessors()) {
-      // Allow propagation across exceptional edges, just be careful not to propagate if the
-      // throwing instruction is a field instruction.
-      if (successor.getPredecessors().size() == 1) {
-        if (block.hasCatchSuccessor(successor)) {
-          Instruction exceptionalExit = block.exceptionalExit();
-          if (exceptionalExit != null && exceptionalExit.isFieldInstruction()) {
-            killActiveFieldsForExceptionalExit(exceptionalExit.asFieldInstruction());
-          }
-        }
-        assert !activeInstanceFieldsAtEntry.containsKey(successor);
-        activeInstanceFieldsAtEntry.put(successor, new HashMap<>(activeInstanceFields));
-        assert !activeStaticFieldsAtEntry.containsKey(successor);
-        activeStaticFieldsAtEntry.put(successor, new HashMap<>(activeStaticFields));
-      }
-    }
-  }
-
-  private void killActiveFields(FieldInstruction instruction) {
-    DexField field = instruction.getField();
-    if (instruction.isInstancePut()) {
-      // Remove all the field/object pairs that refer to this field to make sure
-      // that we are conservative.
-      List<FieldAndObject> keysToRemove = new ArrayList<>();
-      for (FieldAndObject key : activeInstanceFields.keySet()) {
-        if (key.field == field) {
-          keysToRemove.add(key);
-        }
-      }
-      keysToRemove.forEach((k) -> activeInstanceFields.remove(k));
-    } else if (instruction.isInstanceGet()) {
-      Value object = instruction.asInstanceGet().object();
-      FieldAndObject fieldAndObject = new FieldAndObject(field, object);
-      activeInstanceFields.remove(fieldAndObject);
-    } else if (instruction.isStaticPut()) {
-      if (field.clazz != code.method.method.holder) {
-        // Accessing a static field on a different object could cause <clinit> to run which
-        // could modify any static field on any other object.
-        activeStaticFields.clear();
-      } else {
-        activeStaticFields.remove(field);
-      }
-    } else if (instruction.isStaticGet()) {
-      if (field.clazz != code.method.method.holder) {
-        // Accessing a static field on a different object could cause <clinit> to run which
-        // could modify any static field on any other object.
-        activeStaticFields.clear();
-      }
-    }
-  }
-
-  // If a field get instruction throws an exception it did not have an effect on the
-  // value of the field. Therefore, when propagating across exceptional edges for a
-  // field get instruction we have to exclude that field from the set of known
-  // field values.
-  private void killActiveFieldsForExceptionalExit(FieldInstruction instruction) {
-    DexField field = instruction.getField();
-    if (instruction.isInstanceGet()) {
-      Value object = instruction.asInstanceGet().object();
-      FieldAndObject fieldAndObject = new FieldAndObject(field, object);
-      activeInstanceFields.remove(fieldAndObject);
-    } else if (instruction.isStaticGet()) {
-      activeStaticFields.remove(field);
-    }
-  }
-
-  private void eliminateRedundantRead(
-      InstructionListIterator it, Instruction redundant, Instruction active) {
-    redundant.outValue().replaceUsers(active.outValue());
-    it.removeOrReplaceByDebugLocalRead();
-    active.outValue().uniquePhiUsers().forEach(Phi::removeTrivialPhi);
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/utils/LineNumberOptimizer.java b/src/main/java/com/android/tools/r8/utils/LineNumberOptimizer.java
index f10ff69..7d7baf8 100644
--- a/src/main/java/com/android/tools/r8/utils/LineNumberOptimizer.java
+++ b/src/main/java/com/android/tools/r8/utils/LineNumberOptimizer.java
@@ -3,6 +3,9 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.utils;
 
+import com.android.tools.r8.cf.code.CfInstruction;
+import com.android.tools.r8.cf.code.CfPosition;
+import com.android.tools.r8.graph.CfCode;
 import com.android.tools.r8.graph.Code;
 import com.android.tools.r8.graph.DexApplication;
 import com.android.tools.r8.graph.DexCode;
@@ -119,17 +122,15 @@
   // PositionRemapper is a stateful function which takes a position (represented by a
   // DexDebugPositionState) and returns a remapped Position.
   private interface PositionRemapper {
-    Position createRemappedPosition(DexDebugPositionState positionState);
+    Position createRemappedPosition(
+        int line, DexString file, DexMethod method, Position callerPosition);
   }
 
   private static class IdentityPositionRemapper implements PositionRemapper {
     @Override
-    public Position createRemappedPosition(DexDebugPositionState positionState) {
-      return new Position(
-          positionState.getCurrentLine(),
-          positionState.getCurrentFile(),
-          positionState.getCurrentMethod(),
-          positionState.getCurrentCallerPosition());
+    public Position createRemappedPosition(
+        int line, DexString file, DexMethod method, Position callerPosition) {
+      return new Position(line, file, method, callerPosition);
     }
   }
 
@@ -137,13 +138,9 @@
     private int nextLineNumber = 1;
 
     @Override
-    public Position createRemappedPosition(DexDebugPositionState positionState) {
-      Position newPosition =
-          new Position(
-              nextLineNumber,
-              positionState.getCurrentFile(),
-              positionState.getCurrentMethod(),
-              null);
+    public Position createRemappedPosition(
+        int line, DexString file, DexMethod method, Position callerPosition) {
+      Position newPosition = new Position(nextLineNumber, file, method, null);
       ++nextLineNumber;
       return newPosition;
     }
@@ -252,57 +249,14 @@
         for (DexEncodedMethod method : methods) {
           List<MappedPosition> mappedPositions = new ArrayList<>();
 
-          if (doesContainPositions(method)) {
-            // Do the actual processing for each method.
-            DexCode dexCode = method.getCode().asDexCode();
-            DexDebugInfo debugInfo = dexCode.getDebugInfo();
-            List<DexDebugEvent> processedEvents = new ArrayList<>();
-
-            // Our pipeline will be:
-            // [debugInfo.events] -> eventFilter -> positionRemapper -> positionEventEmitter ->
-            // [processedEvents]
-            PositionEventEmitter positionEventEmitter =
-                new PositionEventEmitter(
-                    application.dexItemFactory, method.method, processedEvents);
-
-            EventFilter eventFilter =
-                new EventFilter(
-                    debugInfo.startLine,
-                    method.method,
-                    processedEvents::add,
-                    positionState -> {
-                      int currentLine = positionState.getCurrentLine();
-                      assert currentLine >= 0;
-                      Position position = positionRemapper.createRemappedPosition(positionState);
-                      mappedPositions.add(
-                          new MappedPosition(
-                              positionState.getCurrentMethod(),
-                              currentLine,
-                              positionState.getCurrentCallerPosition(),
-                              position.line));
-                      positionEventEmitter.emitPositionEvents(
-                          positionState.getCurrentPc(), position);
-                    });
-            for (DexDebugEvent event : debugInfo.events) {
-              event.accept(eventFilter);
+          Code code = method.getCode();
+          if (code != null) {
+            if (code.isDexCode() && doesContainPositions(code.asDexCode())) {
+              optimizeDexCodePositions(
+                  method, application, positionRemapper, mappedPositions, identityMapping);
+            } else if (code.isCfCode() && doesContainPositions(code.asCfCode())) {
+              optimizeCfCodePositions(method, positionRemapper, mappedPositions);
             }
-
-            DexDebugInfo optimizedDebugInfo =
-                new DexDebugInfo(
-                    positionEventEmitter.getStartLine(),
-                    debugInfo.parameters,
-                    processedEvents.toArray(new DexDebugEvent[processedEvents.size()]));
-
-            // TODO(tamaskenez) Remove this as soon as we have external tests testing not only the
-            // remapping but whether the non-positional debug events remain intact.
-            if (identityMapping) {
-              assert optimizedDebugInfo.startLine == debugInfo.startLine;
-              assert optimizedDebugInfo.events.length == debugInfo.events.length;
-              for (int i = 0; i < debugInfo.events.length; ++i) {
-                assert optimizedDebugInfo.events[i].equals(debugInfo.events[i]);
-              }
-            }
-            dexCode.setDebugInfo(optimizedDebugInfo);
           }
 
           MethodSignature originalSignature = MethodSignature.fromDexMethod(method.method);
@@ -382,21 +336,33 @@
     return classNameMapperBuilder.build();
   }
 
+  private static int getMethodStartLine(DexEncodedMethod method) {
+    Code code = method.getCode();
+    if (code == null) {
+      return 0;
+    }
+    if (code.isDexCode()) {
+      DexDebugInfo dexDebugInfo = code.asDexCode().getDebugInfo();
+      return dexDebugInfo == null ? 0 : dexDebugInfo.startLine;
+    } else if (code.isCfCode()) {
+      List<CfInstruction> instructions = code.asCfCode().getInstructions();
+      for (CfInstruction instruction : instructions) {
+        if (!(instruction instanceof CfPosition)) {
+          continue;
+        }
+        return ((CfPosition) instruction).getPosition().line;
+      }
+    }
+    return 0;
+  }
+
   // Sort by startline, then DexEncodedMethod.slowCompare.
   // Use startLine = 0 if no debuginfo.
   private static void sortMethods(List<DexEncodedMethod> methods) {
     methods.sort(
         (lhs, rhs) -> {
-          Code lhsCode = lhs.getCode();
-          Code rhsCode = rhs.getCode();
-          DexCode lhsDexCode =
-              lhsCode == null || !lhsCode.isDexCode() ? null : lhsCode.asDexCode();
-          DexCode rhsDexCode =
-              rhsCode == null || !rhsCode.isDexCode() ? null : rhsCode.asDexCode();
-          DexDebugInfo lhsDebugInfo = lhsDexCode == null ? null : lhsDexCode.getDebugInfo();
-          DexDebugInfo rhsDebugInfo = rhsDexCode == null ? null : rhsDexCode.getDebugInfo();
-          int lhsStartLine = lhsDebugInfo == null ? 0 : lhsDebugInfo.startLine;
-          int rhsStartLine = rhsDebugInfo == null ? 0 : rhsDebugInfo.startLine;
+          int lhsStartLine = getMethodStartLine(lhs);
+          int rhsStartLine = getMethodStartLine(rhs);
           int startLineDiff = lhsStartLine - rhsStartLine;
           if (startLineDiff != 0) return startLineDiff;
           return DexEncodedMethod.slowCompare(lhs, rhs);
@@ -453,10 +419,19 @@
 
   private static boolean doesContainPositions(DexEncodedMethod method) {
     Code code = method.getCode();
-    if (code == null || !code.isDexCode()) {
+    if (code == null) {
       return false;
     }
-    DexDebugInfo debugInfo = code.asDexCode().getDebugInfo();
+    if (code.isDexCode()) {
+      return doesContainPositions(code.asDexCode());
+    } else if (code.isCfCode()) {
+      return doesContainPositions(code.asCfCode());
+    }
+    return false;
+  }
+
+  private static boolean doesContainPositions(DexCode dexCode) {
+    DexDebugInfo debugInfo = dexCode.getDebugInfo();
     if (debugInfo == null) {
       return false;
     }
@@ -467,4 +442,114 @@
     }
     return false;
   }
+
+  private static boolean doesContainPositions(CfCode cfCode) {
+    List<CfInstruction> instructions = cfCode.getInstructions();
+    for (CfInstruction instruction : instructions) {
+      if (instruction instanceof CfPosition) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private static void optimizeDexCodePositions(
+      DexEncodedMethod method,
+      DexApplication application,
+      PositionRemapper positionRemapper,
+      List<MappedPosition> mappedPositions,
+      boolean identityMapping) {
+    // Do the actual processing for each method.
+    DexCode dexCode = method.getCode().asDexCode();
+    DexDebugInfo debugInfo = dexCode.getDebugInfo();
+    List<DexDebugEvent> processedEvents = new ArrayList<>();
+
+    // Our pipeline will be:
+    // [debugInfo.events] -> eventFilter -> positionRemapper -> positionEventEmitter ->
+    // [processedEvents]
+    PositionEventEmitter positionEventEmitter =
+        new PositionEventEmitter(application.dexItemFactory, method.method, processedEvents);
+
+    EventFilter eventFilter =
+        new EventFilter(
+            debugInfo.startLine,
+            method.method,
+            processedEvents::add,
+            positionState -> {
+              int currentLine = positionState.getCurrentLine();
+              assert currentLine >= 0;
+              Position position =
+                  positionRemapper.createRemappedPosition(
+                      positionState.getCurrentLine(),
+                      positionState.getCurrentFile(),
+                      positionState.getCurrentMethod(),
+                      positionState.getCurrentCallerPosition());
+              mappedPositions.add(
+                  new MappedPosition(
+                      positionState.getCurrentMethod(),
+                      currentLine,
+                      positionState.getCurrentCallerPosition(),
+                      position.line));
+              positionEventEmitter.emitPositionEvents(positionState.getCurrentPc(), position);
+            });
+    for (DexDebugEvent event : debugInfo.events) {
+      event.accept(eventFilter);
+    }
+
+    DexDebugInfo optimizedDebugInfo =
+        new DexDebugInfo(
+            positionEventEmitter.getStartLine(),
+            debugInfo.parameters,
+            processedEvents.toArray(new DexDebugEvent[processedEvents.size()]));
+
+    // TODO(b/111253214) Remove this as soon as we have external tests testing not only the
+    // remapping but whether the non-positional debug events remain intact.
+    if (identityMapping) {
+      assert optimizedDebugInfo.startLine == debugInfo.startLine;
+      assert optimizedDebugInfo.events.length == debugInfo.events.length;
+      for (int i = 0; i < debugInfo.events.length; ++i) {
+        assert optimizedDebugInfo.events[i].equals(debugInfo.events[i]);
+      }
+    }
+    dexCode.setDebugInfo(optimizedDebugInfo);
+  }
+
+  private static void optimizeCfCodePositions(
+      DexEncodedMethod method,
+      PositionRemapper positionRemapper,
+      List<MappedPosition> mappedPositions) {
+    // Do the actual processing for each method.
+    CfCode oldCode = method.getCode().asCfCode();
+    List<CfInstruction> oldInstructions = oldCode.getInstructions();
+    List<CfInstruction> newInstructions = new ArrayList<>(oldInstructions.size());
+    for (int i = 0; i < oldInstructions.size(); ++i) {
+      CfInstruction oldInstruction = oldInstructions.get(i);
+      CfInstruction newInstruction;
+      if (oldInstruction instanceof CfPosition) {
+        CfPosition cfPosition = (CfPosition) oldInstruction;
+        Position oldPosition = cfPosition.getPosition();
+        Position newPosition =
+            positionRemapper.createRemappedPosition(
+                oldPosition.line, oldPosition.file, oldPosition.method, oldPosition.callerPosition);
+        mappedPositions.add(
+            new MappedPosition(
+                oldPosition.method,
+                oldPosition.line,
+                oldPosition.callerPosition,
+                newPosition.line));
+        newInstruction = new CfPosition(cfPosition.getLabel(), newPosition);
+      } else {
+        newInstruction = oldInstruction;
+      }
+      newInstructions.add(newInstruction);
+    }
+    method.setCode(
+        new CfCode(
+            oldCode.getMethod(),
+            oldCode.getMaxStack(),
+            oldCode.getMaxLocals(),
+            newInstructions,
+            oldCode.getTryCatchRanges(),
+            oldCode.getLocalVariables()));
+  }
 }
diff --git a/src/test/examples/shaking19/Shaking.java b/src/test/examples/shaking19/Shaking.java
new file mode 100644
index 0000000..da8de41
--- /dev/null
+++ b/src/test/examples/shaking19/Shaking.java
@@ -0,0 +1,28 @@
+// 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 shaking19;
+
+public class Shaking {
+
+  public static void main(String[] args) {
+    A obj = new B();
+    obj.m();
+  }
+
+  public static class A {
+
+    // Since A is never instantiated and B overrides method m(), this is dead code.
+    public void m() {
+      System.out.println("In A.m()");
+    }
+  }
+
+  public static class B extends A {
+
+    @Override
+    public void m() {
+      System.out.println("In B.m()");
+    }
+  }
+}
diff --git a/src/test/examples/shaking19/keep-rules.txt b/src/test/examples/shaking19/keep-rules.txt
new file mode 100644
index 0000000..cbc332e
--- /dev/null
+++ b/src/test/examples/shaking19/keep-rules.txt
@@ -0,0 +1,9 @@
+# Copyright (c) 2017, 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.
+
+# Keep the application entry point. Get rid of everything that is not
+# reachable from there.
+-keep public class shaking19.Shaking {
+  public static void main(...);
+}
diff --git a/src/test/examples/uninitializedfinal/UninitializedFinalFieldLeak.java b/src/test/examples/uninitializedfinal/UninitializedFinalFieldLeak.java
deleted file mode 100644
index 781d2b4..0000000
--- a/src/test/examples/uninitializedfinal/UninitializedFinalFieldLeak.java
+++ /dev/null
@@ -1,57 +0,0 @@
-// 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 uninitializedfinal;
-
-// Test that leaks an instance before its final field has been initialized to a thread that
-// reads that field. This tests that redundant field load elimination does not eliminate
-// field reads (even of final fields) that cross a monitor operation.
-public class UninitializedFinalFieldLeak {
-
-  public static class PollingThread extends Thread {
-    public int result = 0;
-    UninitializedFinalFieldLeak f;
-
-    PollingThread(UninitializedFinalFieldLeak f) {
-      this.f = f;
-    }
-
-    // Read the field a number of times. Then lock on the object to await field initialization.
-    public void run() {
-      result += f.i;
-      result += f.i;
-      result += f.i;
-      f.threadReadsDone = true;
-      synchronized (f) {
-        result += f.i;
-      }
-      // The right result is 42. Reading the uninitialized 0 three times and then
-      // reading the initialized value. It is safe to remove the two redundant loads
-      // before the monitor operation.
-      System.out.println(result);
-    }
-  }
-
-  public final int i;
-  public volatile boolean threadReadsDone = false;
-
-  public UninitializedFinalFieldLeak() throws InterruptedException {
-    // Leak the object to a thread and start the thread with the lock on the object taken.
-    // Then allow the other thread to run and read the uninitialized field.
-    // Finally, initialize the field and release the lock.
-    PollingThread t = new PollingThread(this);
-    synchronized (this) {
-      t.start();
-      while (!threadReadsDone) {
-        Thread.yield();
-      }
-      i = 42;
-    }
-    t.join();
-  }
-
-  public static void main(String[] args) throws InterruptedException {
-    new UninitializedFinalFieldLeak();
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/R8RunExamplesTest.java b/src/test/java/com/android/tools/r8/R8RunExamplesTest.java
index 221d427..36f7594 100644
--- a/src/test/java/com/android/tools/r8/R8RunExamplesTest.java
+++ b/src/test/java/com/android/tools/r8/R8RunExamplesTest.java
@@ -45,11 +45,9 @@
         "instancevariable.InstanceVariable",
         "instanceofstring.InstanceofString",
         "invoke.Invoke",
-        "invokeempty.InvokeEmpty",
         "jumbostring.JumboString",
         "loadconst.LoadConst",
         "loop.UdpServer",
-        "nestedtrycatches.NestedTryCatches",
         "newarray.NewArray",
         "regalloc.RegAlloc",
         "returns.Returns",
@@ -60,7 +58,9 @@
         "throwing.Throwing",
         "trivial.Trivial",
         "trycatch.TryCatch",
+        "nestedtrycatches.NestedTryCatches",
         "trycatchmany.TryCatchMany",
+        "invokeempty.InvokeEmpty",
         "regress.Regress",
         "regress2.Regress2",
         "regress_37726195.Regress",
@@ -82,7 +82,6 @@
         "enclosingmethod_proguarded.Main",
         "interfaceinlining.Main",
         "switchmaps.Switches",
-        "uninitializedfinal.UninitializedFinalFieldLeak",
     };
 
     List<String[]> fullTestList = new ArrayList<>(tests.length * 2);
diff --git a/src/test/java/com/android/tools/r8/debug/LineNumberOptimizationTest.java b/src/test/java/com/android/tools/r8/debug/LineNumberOptimizationTest.java
index d944a75..6e1c05f 100644
--- a/src/test/java/com/android/tools/r8/debug/LineNumberOptimizationTest.java
+++ b/src/test/java/com/android/tools/r8/debug/LineNumberOptimizationTest.java
@@ -7,12 +7,18 @@
 import com.android.tools.r8.OutputMode;
 import com.android.tools.r8.R8Command;
 import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.debug.DebugTestConfig.RuntimeKind;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.InternalOptions.LineNumberOptimization;
+import com.google.common.collect.ImmutableList;
 import java.nio.file.Path;
+import java.util.Collection;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
 
 /** Tests source file and line numbers on inlined methods. */
+@RunWith(Parameterized.class)
 public class LineNumberOptimizationTest extends DebugTestBase {
 
   private static final int[] ORIGINAL_LINE_NUMBERS = {20, 7, 8, 28, 8, 20, 21, 12, 21, 22, 16, 22};
@@ -26,25 +32,53 @@
   private static final String FILE2 = CLASS2 + ".java";
   private static final String MAIN_SIGNATURE = "([Ljava/lang/String;)V";
 
+  private RuntimeKind runtimeKind;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static Collection<Object[]> setup() {
+    return ImmutableList.of(
+        new Object[] {"CF", RuntimeKind.CF}, new Object[] {"DEX", RuntimeKind.DEX});
+  }
+
+  public LineNumberOptimizationTest(String name, RuntimeKind runtimeKind) {
+    this.runtimeKind = runtimeKind;
+  }
+
   private static DebugTestConfig makeConfig(
       LineNumberOptimization lineNumberOptimization,
       boolean writeProguardMap,
-      boolean dontOptimizeByEnablingDebug)
+      boolean dontOptimizeByEnablingDebug,
+      RuntimeKind runtimeKind)
       throws Exception {
-    AndroidApiLevel minSdk = ToolHelper.getMinApiLevelForDexVm();
     Path outdir = temp.newFolder().toPath();
     Path outjar = outdir.resolve("r8_compiled.jar");
-    Path proguardMapPath = writeProguardMap ? outdir.resolve("proguard.map") : null;
+
     R8Command.Builder builder =
         R8Command.builder()
             .addProgramFiles(DEBUGGEE_JAR)
-            .setMinApiLevel(minSdk.getLevel())
-            .addLibraryFiles(ToolHelper.getAndroidJar(minSdk))
-            .setMode(dontOptimizeByEnablingDebug ? CompilationMode.DEBUG : CompilationMode.RELEASE)
-            .setOutput(outjar, OutputMode.DexIndexed);
-    if (proguardMapPath != null) {
-      builder.setProguardMapOutputPath(proguardMapPath);
+            .setMode(dontOptimizeByEnablingDebug ? CompilationMode.DEBUG : CompilationMode.RELEASE);
+    DebugTestConfig config = null;
+
+    if (runtimeKind == RuntimeKind.CF) {
+      builder.setOutput(outjar, OutputMode.ClassFile);
+      config = new CfDebugTestConfig(outjar);
+    } else {
+      assert (runtimeKind == RuntimeKind.DEX);
+      AndroidApiLevel minSdk = ToolHelper.getMinApiLevelForDexVm();
+      builder
+          .setMinApiLevel(minSdk.getLevel())
+          .addLibraryFiles(ToolHelper.getAndroidJar(minSdk))
+          .setOutput(outjar, OutputMode.DexIndexed);
+      config = new D8DebugTestConfig();
     }
+
+    config.addPaths(outjar);
+    if (writeProguardMap) {
+      Path proguardMapPath = outdir.resolve("proguard.map");
+      builder.setProguardMapOutputPath(proguardMapPath);
+      config.setProguardMap(proguardMapPath);
+    }
+
     ToolHelper.runR8(
         builder.build(),
         options -> {
@@ -53,46 +87,52 @@
           }
           options.enableInlining = false;
         });
-    DebugTestConfig config = new D8DebugTestConfig();
-    config.addPaths(outjar);
-    config.setProguardMap(proguardMapPath);
+
     return config;
   }
 
   @Test
   public void testIdentityCompilation() throws Throwable {
     // Compilation will fail if the identity translation does.
-    makeConfig(LineNumberOptimization.IDENTITY_MAPPING, true, false);
+    makeConfig(LineNumberOptimization.IDENTITY_MAPPING, true, false, runtimeKind);
   }
 
   @Test
   public void testNotOptimized() throws Throwable {
-    testRelease(makeConfig(LineNumberOptimization.OFF, false, false), ORIGINAL_LINE_NUMBERS);
+    testRelease(
+        makeConfig(LineNumberOptimization.OFF, false, false, runtimeKind), ORIGINAL_LINE_NUMBERS);
   }
 
   @Test
   public void testNotOptimizedWithMap() throws Throwable {
-    testRelease(makeConfig(LineNumberOptimization.OFF, true, false), ORIGINAL_LINE_NUMBERS);
+    testRelease(
+        makeConfig(LineNumberOptimization.OFF, true, false, runtimeKind), ORIGINAL_LINE_NUMBERS);
   }
 
   @Test
   public void testNotOptimizedByEnablingDebug() throws Throwable {
-    testDebug(makeConfig(LineNumberOptimization.OFF, false, true), ORIGINAL_LINE_NUMBERS_DEBUG);
+    testDebug(
+        makeConfig(LineNumberOptimization.OFF, false, true, runtimeKind),
+        ORIGINAL_LINE_NUMBERS_DEBUG);
   }
 
   @Test
   public void testNotOptimizedByEnablingDebugWithMap() throws Throwable {
-    testDebug(makeConfig(LineNumberOptimization.OFF, true, true), ORIGINAL_LINE_NUMBERS_DEBUG);
+    testDebug(
+        makeConfig(LineNumberOptimization.OFF, true, true, runtimeKind),
+        ORIGINAL_LINE_NUMBERS_DEBUG);
   }
 
   @Test
   public void testOptimized() throws Throwable {
-    testRelease(makeConfig(LineNumberOptimization.ON, false, false), OPTIMIZED_LINE_NUMBERS);
+    testRelease(
+        makeConfig(LineNumberOptimization.ON, false, false, runtimeKind), OPTIMIZED_LINE_NUMBERS);
   }
 
   @Test
   public void testOptimizedWithMap() throws Throwable {
-    testRelease(makeConfig(LineNumberOptimization.ON, true, false), ORIGINAL_LINE_NUMBERS);
+    testRelease(
+        makeConfig(LineNumberOptimization.ON, true, false, runtimeKind), ORIGINAL_LINE_NUMBERS);
   }
 
   private void testDebug(DebugTestConfig config, int[] lineNumbers) throws Throwable {
diff --git a/src/test/java/com/android/tools/r8/shaking/examples/TreeShaking19Test.java b/src/test/java/com/android/tools/r8/shaking/examples/TreeShaking19Test.java
new file mode 100644
index 0000000..e5be477
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/examples/TreeShaking19Test.java
@@ -0,0 +1,62 @@
+// 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.shaking.examples;
+
+import static com.android.tools.r8.utils.DexInspectorMatchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.junit.Assert.assertThat;
+
+import com.android.tools.r8.TestBase.MinifyMode;
+import com.android.tools.r8.shaking.TreeShakingTest;
+import com.android.tools.r8.utils.DexInspector;
+import com.android.tools.r8.utils.DexInspector.ClassSubject;
+import com.android.tools.r8.utils.DexInspector.MethodSubject;
+import com.google.common.collect.ImmutableList;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class TreeShaking19Test extends TreeShakingTest {
+
+  @Parameters(name = "mode:{0}-{1} minify:{2}")
+  public static Collection<Object[]> data() {
+    List<Object[]> parameters = new ArrayList<>();
+    for (MinifyMode minify : MinifyMode.values()) {
+      parameters.add(new Object[] {Frontend.JAR, Backend.CF, minify});
+      parameters.add(new Object[] {Frontend.JAR, Backend.DEX, minify});
+      parameters.add(new Object[] {Frontend.DEX, Backend.DEX, minify});
+    }
+    return parameters;
+  }
+
+  public TreeShaking19Test(Frontend frontend, Backend backend, MinifyMode minify) {
+    super("examples/shaking19", "shaking19.Shaking", frontend, backend, minify);
+  }
+
+  @Ignore("b/111199171")
+  @Test
+  public void test() throws Exception {
+    runTest(
+        TreeShaking19Test::unusedRemoved,
+        null,
+        null,
+        ImmutableList.of("src/test/examples/shaking19/keep-rules.txt"),
+        // Disable vertical class merging to prevent A from being merged into B.
+        opt -> opt.enableClassMerging = false);
+  }
+
+  private static void unusedRemoved(DexInspector inspector) {
+    ClassSubject clazz = inspector.clazz("shaking19.Shaking$A");
+    assertThat(clazz, isPresent());
+
+    MethodSubject method = clazz.method("void", "m", ImmutableList.of());
+    assertThat(method, not(isPresent()));
+  }
+}