diff --git a/src/main/java/com/android/tools/r8/R8Command.java b/src/main/java/com/android/tools/r8/R8Command.java
index 22d08f5..7eff6fa 100644
--- a/src/main/java/com/android/tools/r8/R8Command.java
+++ b/src/main/java/com/android/tools/r8/R8Command.java
@@ -174,7 +174,7 @@
       return self();
     }
 
-    Builder setProguardMapOutput(Path path) {
+    public Builder setProguardMapOutput(Path path) {
       this.proguardMapOutput = path;
       return self();
     }
diff --git a/src/main/java/com/android/tools/r8/naming/ClassNaming.java b/src/main/java/com/android/tools/r8/naming/ClassNaming.java
index a00455f..74c5006 100644
--- a/src/main/java/com/android/tools/r8/naming/ClassNaming.java
+++ b/src/main/java/com/android/tools/r8/naming/ClassNaming.java
@@ -7,7 +7,9 @@
 import java.io.IOException;
 import java.io.StringWriter;
 import java.io.Writer;
+import java.util.ArrayList;
 import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.function.Consumer;
 
@@ -19,7 +21,7 @@
 public class ClassNaming {
 
   public final String originalName;
-  final String renamedName;
+  public final String renamedName;
 
   /**
    * Mapping from the renamed signature to the naming information for a member.
@@ -52,6 +54,16 @@
     return null;
   }
 
+  public List<MemberNaming> lookupByOriginalName(String originalName) {
+    List<MemberNaming> result = new ArrayList<>();
+    for (MemberNaming naming : members.values()) {
+      if (naming.signature.name.equals(originalName)) {
+        result.add(naming);
+      }
+    }
+    return result;
+  }
+
   public void forAllMemberNaming(Consumer<MemberNaming> consumer) {
     members.values().forEach(consumer);
   }
diff --git a/src/main/java/com/android/tools/r8/naming/MemberNaming.java b/src/main/java/com/android/tools/r8/naming/MemberNaming.java
index 762bdb6..5f2ea93 100644
--- a/src/main/java/com/android/tools/r8/naming/MemberNaming.java
+++ b/src/main/java/com/android/tools/r8/naming/MemberNaming.java
@@ -8,6 +8,7 @@
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.naming.MemberNaming.Signature.SignatureKind;
+import com.android.tools.r8.utils.DescriptorUtils;
 import java.io.IOException;
 import java.io.StringWriter;
 import java.io.Writer;
@@ -15,6 +16,7 @@
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
+import org.objectweb.asm.Type;
 
 /**
  * Stores renaming information for a member.
@@ -281,6 +283,20 @@
           method.proto.returnType.toSourceString(), paramNames);
     }
 
+    public static MethodSignature fromSignature(String name, String signature) {
+      Type[] parameterDescriptors = Type.getArgumentTypes(signature);
+      Type returnDescriptor = Type.getReturnType(signature);
+      String[] parameterTypes = new String[parameterDescriptors.length];
+      for (int i = 0; i < parameterDescriptors.length; i++) {
+        parameterTypes[i] =
+            DescriptorUtils.descriptorToJavaType(parameterDescriptors[i].getDescriptor());
+      }
+      return new MethodSignature(
+          name,
+          DescriptorUtils.descriptorToJavaType(returnDescriptor.getDescriptor()),
+          parameterTypes);
+    }
+
     public static MethodSignature initializer(String[] parameters) {
       return new MethodSignature(Constants.INSTANCE_INITIALIZER_NAME, "void", parameters);
     }
diff --git a/src/main/java/com/android/tools/r8/utils/FileSystemOutputSink.java b/src/main/java/com/android/tools/r8/utils/FileSystemOutputSink.java
index 9ceee1f..c0aef0a 100644
--- a/src/main/java/com/android/tools/r8/utils/FileSystemOutputSink.java
+++ b/src/main/java/com/android/tools/r8/utils/FileSystemOutputSink.java
@@ -45,7 +45,12 @@
 
   @Override
   public void writeProguardMapFile(byte[] contents) throws IOException {
-    writeToFile(options.proguardConfiguration.getPrintMappingFile(), System.out, contents);
+    if (options.proguardConfiguration.getPrintMappingFile() != null) {
+      writeToFile(options.proguardConfiguration.getPrintMappingFile(), System.out, contents);
+    }
+    if (options.proguardMapOutput != null) {
+      writeToFile(options.proguardMapOutput, System.out, contents);
+    }
   }
 
   @Override
diff --git a/src/test/debugTestResources/Minified.java b/src/test/debugTestResources/Minified.java
new file mode 100644
index 0000000..af90776
--- /dev/null
+++ b/src/test/debugTestResources/Minified.java
@@ -0,0 +1,25 @@
+// 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.
+
+public class Minified {
+  private static class Inner {
+    public static int innerTest() {
+      System.out.println("innerTest");
+      return 0;
+    }
+  }
+
+  private static void test() {
+    System.out.println("test");
+    Inner.innerTest();
+  }
+
+  private static void test(int i) {
+    System.out.println("test" + i);
+  }
+
+  public static void main(String[] args) {
+    test();
+  }
+}
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 3b12b43..35760ef 100644
--- a/src/test/java/com/android/tools/r8/debug/DebugTestBase.java
+++ b/src/test/java/com/android/tools/r8/debug/DebugTestBase.java
@@ -13,6 +13,12 @@
 import com.android.tools.r8.ToolHelper.DexVm.Version;
 import com.android.tools.r8.ToolHelper.ProcessResult;
 import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.naming.ClassNameMapper;
+import com.android.tools.r8.naming.ClassNaming;
+import com.android.tools.r8.naming.MemberNaming;
+import com.android.tools.r8.naming.MemberNaming.MethodSignature;
+import com.android.tools.r8.naming.MemberNaming.Signature;
+import com.android.tools.r8.naming.ProguardMapReader;
 import com.android.tools.r8.shaking.ProguardConfiguration;
 import com.android.tools.r8.shaking.ProguardRuleParserException;
 import com.android.tools.r8.utils.AndroidApiLevel;
@@ -23,6 +29,7 @@
 import it.unimi.dsi.fastutil.longs.LongList;
 import java.io.File;
 import java.io.IOException;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayDeque;
@@ -110,6 +117,7 @@
       .get(ToolHelper.BUILD_DIR, "test", "debug_test_resources_java8.jar");
   private static final Path DEBUGGEE_KOTLIN_JAR = Paths
       .get(ToolHelper.BUILD_DIR, "test", "debug_test_resources_kotlin.jar");
+  private static final String PROGUARD_MAP_FILENAME = "proguard.map";
 
   @ClassRule
   public static TemporaryFolder temp = new TemporaryFolder();
@@ -127,6 +135,9 @@
     setUp(null, null);
   }
 
+  protected static List<String> proguardConfigurations = Collections.<String>emptyList();
+  protected static boolean writeProguardMap = false;
+
   protected static void setUp(
       Consumer<InternalOptions> optionsConsumer,
       Consumer<ProguardConfiguration.Builder> pgConsumer)
@@ -206,6 +217,12 @@
             .setMinApiLevel(minSdk)
             .setMode(CompilationMode.DEBUG)
             .addLibraryFiles(Paths.get(ToolHelper.getAndroidJar(minSdk)));
+    if (writeProguardMap) {
+      builder.setProguardMapOutput(dexOutputDir.resolve(PROGUARD_MAP_FILENAME));
+    }
+    if (!proguardConfigurations.isEmpty()) {
+      builder.addProguardConfiguration(proguardConfigurations);
+    }
     if (pgConsumer != null) {
       builder.addProguardConfigurationConsumer(pgConsumer);
     }
@@ -326,17 +343,23 @@
 
     String[] paths = new String[extraPaths.size() + 2];
     int indexPath = 0;
+    ClassNameMapper classNameMapper = null;
     if (RUNTIME_KIND == RuntimeKind.JAVA) {
       paths[indexPath++] = JDWP_JAR.toString();
       paths[indexPath++] = languageFeatures.getJarPath().toString();
     } else {
       paths[indexPath++] = jdwpDexD8.toString();
       paths[indexPath++] = languageFeatures.getDexPath().toString();
+      Path proguardMapPath = Paths.get(paths[indexPath - 1]).resolveSibling(PROGUARD_MAP_FILENAME);
+      if (Files.exists(proguardMapPath)) {
+        classNameMapper = ProguardMapReader.mapperFromFile(proguardMapPath);
+      }
     }
     for (Path extraPath : extraPaths) {
       paths[indexPath++] = extraPath.toString();
     }
-    new JUnit3Wrapper(debuggeeClass, paths, commands).runBare();
+
+    new JUnit3Wrapper(debuggeeClass, paths, commands, classNameMapper).runBare();
   }
 
   protected final JUnit3Wrapper.Command run() {
@@ -513,14 +536,173 @@
     private DebuggeeState debuggeeState = null;
 
     private final Deque<Command> commandsQueue;
+    private final Translator translator;
 
     // Active event requests.
     private final Map<Integer, EventHandler> events = new TreeMap<>();
 
-    JUnit3Wrapper(String debuggeeClassName, String[] debuggeePath, List<Command> commands) {
+    /**
+     * The Translator interface provides mapping between the class and method names and line numbers
+     * found in the binary file and their original forms.
+     *
+     * <p>Terminology:
+     *
+     * <p>The term 'original' refers to the names and line numbers found in the original source
+     * code. The term 'obfuscated' refers to the names and line numbers in the binary. Note that
+     * they may not actually be obfuscated:
+     *
+     * <p>- The obfuscated class and method names can be identical to the original ones if
+     * minification is disabled or they are 'keep' classes/methods. - The obfuscated line numbers
+     * can be identical to the original ones if neither inlining nor line number remapping took
+     * place.
+     */
+    private interface Translator {
+      public String getOriginalClassName(String obfuscatedClassName);
+
+      public String getOriginalMethodName(
+          String obfuscatedClassName, String obfuscatedMethodName, String methodSignature);
+
+      public int getOriginalLineNumber(int obfuscatedLineNumber);
+
+      public String getObfuscatedClassName(String originalClassName);
+
+      public String getObfuscatedMethodName(
+          String originalClassName, String originalMethodName, String methodSignature);
+    }
+
+    private class IdentityTranslator implements Translator {
+
+      @Override
+      public String getOriginalClassName(String obfuscatedClassName) {
+        return obfuscatedClassName;
+      }
+
+      @Override
+      public String getOriginalMethodName(
+          String obfuscatedClassName, String obfuscatedMethodName, String methodSignature) {
+        return obfuscatedMethodName;
+      }
+
+      @Override
+      public int getOriginalLineNumber(int obfuscatedLineNumber) {
+        return obfuscatedLineNumber;
+      }
+
+      @Override
+      public String getObfuscatedClassName(String originalClassName) {
+        return originalClassName;
+      }
+
+      @Override
+      public String getObfuscatedMethodName(
+          String originalClassName, String originalMethodName, String methodSignature) {
+        return originalMethodName;
+      }
+    }
+
+    private class ClassNameMapperTranslator extends IdentityTranslator {
+      private final ClassNameMapper classNameMapper;
+
+      public ClassNameMapperTranslator(ClassNameMapper classNameMapper) {
+        this.classNameMapper = classNameMapper;
+      }
+
+      @Override
+      public String getOriginalClassName(String obfuscatedClassName) {
+        // TODO(tamaskenez) Watch for inline methods (we can be in a different class).
+        return classNameMapper.deobfuscateClassName(obfuscatedClassName);
+      }
+
+      @Override
+      public String getOriginalMethodName(
+          String obfuscatedClassName, String obfuscatedMethodName, String methodSignature) {
+        MemberNaming memberNaming =
+            getMemberNaming(obfuscatedClassName, obfuscatedMethodName, methodSignature);
+        if (memberNaming == null) {
+          return obfuscatedMethodName;
+        }
+
+        Signature originalSignature = memberNaming.getOriginalSignature();
+        return originalSignature.name;
+      }
+
+      @Override
+      public int getOriginalLineNumber(int obfuscatedLineNumber) {
+        return obfuscatedLineNumber;
+        // TODO(tamaskenez) Map possibly reassigned line number to original, watch for inline.
+        // methods
+      }
+
+      @Override
+      public String getObfuscatedClassName(String originalClassName) {
+        // TODO(tamaskenez) Watch for inline methods (we can be in a different class).
+        String obfuscatedClassName =
+            classNameMapper.getObfuscatedToOriginalMapping().inverse().get(originalClassName);
+        return obfuscatedClassName == null ? originalClassName : obfuscatedClassName;
+      }
+
+      @Override
+      public String getObfuscatedMethodName(
+          String originalClassName, String originalMethodName, String methodSignatureOrNull) {
+        ClassNaming naming;
+        String obfuscatedClassName =
+            classNameMapper.getObfuscatedToOriginalMapping().inverse().get(originalClassName);
+        if (obfuscatedClassName != null) {
+          naming = classNameMapper.getClassNaming(obfuscatedClassName);
+        } else {
+          return originalMethodName;
+        }
+
+        if (methodSignatureOrNull == null) {
+          List<MemberNaming> memberNamings = naming.lookupByOriginalName(originalMethodName);
+          if (memberNamings.isEmpty()) {
+            return originalMethodName;
+          } else if (memberNamings.size() == 1) {
+            return memberNamings.get(0).getRenamedName();
+          } else
+            throw new RuntimeException(
+                String.format(
+                    "Looking up method %s.%s without signature is ambiguous (%d candidates).",
+                    originalClassName, originalMethodName, memberNamings.size()));
+        } else {
+          MethodSignature originalSignature =
+              MethodSignature.fromSignature(originalMethodName, methodSignatureOrNull);
+          MemberNaming memberNaming = naming.lookupByOriginalSignature(originalSignature);
+          if (memberNaming == null) {
+            return originalMethodName;
+          }
+
+          return memberNaming.getRenamedName();
+        }
+      }
+
+      /** Assumes classNameMapper is valid. Return null if no member naming found. */
+      private MemberNaming getMemberNaming(
+          String obfuscatedClassName, String obfuscatedMethodName, String genericMethodSignature) {
+        ClassNaming classNaming = classNameMapper.getClassNaming(obfuscatedClassName);
+        if (classNaming == null) {
+          return null;
+        }
+
+        MethodSignature renamedSignature =
+            MethodSignature.fromSignature(obfuscatedMethodName, genericMethodSignature);
+        return classNaming.lookup(renamedSignature);
+      }
+    }
+
+    JUnit3Wrapper(
+        String debuggeeClassName,
+        String[] debuggeePath,
+        List<Command> commands,
+        ClassNameMapper classNameMapper) {
       this.debuggeeClassName = debuggeeClassName;
       this.debuggeePath = debuggeePath;
       this.commandsQueue = new ArrayDeque<>(commands);
+      if (classNameMapper == null) {
+        this.translator = new IdentityTranslator();
+      } else {
+        this.translator = new ClassNameMapperTranslator(classNameMapper);
+      }
     }
 
     @Override
@@ -733,10 +915,12 @@
 
         private final long frameId;
         private final Location location;
+        private final Translator translator;
 
-        public DebuggeeFrame(long frameId, Location location) {
+        public DebuggeeFrame(long frameId, Location location, Translator translator) {
           this.frameId = frameId;
           this.location = location;
+          this.translator = translator;
         }
 
         public long getFrameId() {
@@ -747,7 +931,7 @@
           return location;
         }
 
-        public int getLineNumber() {
+        private int getObfuscatedLineNumber() {
           Location location = getLocation();
           ReplyPacket reply = getMirror().getLineTable(location.classID, location.methodID);
           if (reply.getErrorCode() != 0) {
@@ -775,10 +959,13 @@
               break;
             }
           }
-
           return line;
         }
 
+        public int getLineNumber() {
+          return translator.getOriginalLineNumber(getObfuscatedLineNumber());
+        }
+
         public String getSourceFile() {
           // TODO(shertz) support JSR-45
           Location location = getLocation();
@@ -874,7 +1061,11 @@
               expectedValue, localValue);
         }
 
-        public String getClassName() {
+        /**
+         * Return class name, as found in the binary. If it has not been obfuscated (minified) it's
+         * identical to the original class name. Otherwise, it's the obfuscated one.
+         */
+        private String getObfuscatedClassName() {
           String classSignature = getClassSignature();
           assert classSignature.charAt(0) == 'L';
           // Remove leading 'L' and trailing ';'
@@ -883,16 +1074,27 @@
           return classSignature.replace('/', '.');
         }
 
+        public String getClassName() {
+          return translator.getOriginalClassName(getObfuscatedClassName());
+        }
+
         public String getClassSignature() {
           Location location = getLocation();
           return getMirror().getClassSignature(location.classID);
         }
 
-        public String getMethodName() {
+        // Return method name as found in the binary. Can be obfuscated (minified).
+        private String getObfuscatedMethodName() {
           Location location = getLocation();
           return getMirror().getMethodName(location.classID, location.methodID);
         }
 
+        // Return original method name.
+        public String getMethodName() {
+          return translator.getOriginalMethodName(
+              getObfuscatedClassName(), getObfuscatedMethodName(), getMethodSignature());
+        }
+
         public String getMethodSignature() {
           Location location = getLocation();
           CommandPacket command = new CommandPacket(ReferenceTypeCommandSet.CommandSetID,
@@ -1138,7 +1340,7 @@
         for (int i = 0; i < frameCount; ++i) {
           long frameId = replyPacket.getNextValueAsFrameID();
           Location location = replyPacket.getNextValueAsLocation();
-          frames.add(debuggeeState.new DebuggeeFrame(frameId, location));
+          frames.add(debuggeeState.new DebuggeeFrame(frameId, location, translator));
         }
         assertAllDataRead(replyPacket);
       }
@@ -1207,7 +1409,8 @@
         @Override
         public void perform(JUnit3Wrapper testBase) {
           VmMirror mirror = testBase.getMirror();
-          String classSignature = getClassSignature(className);
+          String obfuscatedClassName = testBase.translator.getObfuscatedClassName(className);
+          String classSignature = getClassSignature(obfuscatedClassName);
           byte typeTag = TypeTag.CLASS;
           long classId = mirror.getClassID(classSignature);
           if (classId == -1) {
@@ -1220,7 +1423,7 @@
             // breakpoint.
             assert requestedClassPrepare == false : "Already requested class prepare";
             requestedClassPrepare = true;
-            ReplyPacket replyPacket = mirror.setClassPrepared(className);
+            ReplyPacket replyPacket = mirror.setClassPrepared(obfuscatedClassName);
             final int classPrepareRequestId = replyPacket.getNextValueAsInt();
             testBase.events.put(Integer.valueOf(classPrepareRequestId), wrapper -> {
               // Remove the CLASS_PREPARE
@@ -1237,7 +1440,10 @@
             });
           } else {
             // The class is available: lookup the method then set the breakpoint.
-            long breakpointMethodId = findMethod(mirror, classId, methodName, methodSignature);
+            String obfuscatedMethodName =
+                testBase.translator.getObfuscatedMethodName(className, methodName, methodSignature);
+            long breakpointMethodId =
+                findMethod(mirror, classId, obfuscatedMethodName, methodSignature);
             long index = testBase.getMethodFirstCodeIndex(classId, breakpointMethodId);
             Assert.assertTrue("No code in method", index >= 0);
             ReplyPacket replyPacket = testBase.getMirror().setBreakpoint(
diff --git a/src/test/java/com/android/tools/r8/debug/MinificationTest.java b/src/test/java/com/android/tools/r8/debug/MinificationTest.java
new file mode 100644
index 0000000..a29562a
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/debug/MinificationTest.java
@@ -0,0 +1,96 @@
+// 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.
+package com.android.tools.r8.debug;
+
+import com.google.common.collect.ImmutableList;
+import java.util.Arrays;
+import java.util.Collection;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+/** Tests local variable information. */
+@RunWith(Parameterized.class)
+public class MinificationTest extends DebugTestBase {
+
+  public static final String SOURCE_FILE = "Minified.java";
+
+  @Parameterized.Parameters(name = "minification: {0}, proguardMap: {1}")
+  public static Collection minificationControl() {
+    return Arrays.asList(new Object[][] {{false, false}, {true, false}, {true, true}});
+  }
+
+  private static boolean firstRun = true;
+  private static boolean minificationEnabled;
+
+  public MinificationTest(boolean enableMinification, boolean writeProguardMap) throws Exception {
+    // TODO(tamaskenez) The way we're shadowing and calling the static setUp() methods should be
+    // updated when we refactor DebugTestBase.
+    if (firstRun
+        || this.minificationEnabled != enableMinification
+        || this.writeProguardMap != writeProguardMap) {
+
+      firstRun = false;
+      this.minificationEnabled = enableMinification;
+      this.writeProguardMap = writeProguardMap;
+
+      if (minificationEnabled) {
+        proguardConfigurations =
+            ImmutableList.of(
+                "-keep public class Minified { public static void main(java.lang.String[]); }");
+        setUp(
+            null,
+            pg -> {
+              pg.addKeepAttributePatterns(ImmutableList.of("SourceFile", "LineNumberTable"));
+            });
+      } else {
+        setUp(null, null);
+      }
+    }
+  }
+
+  @BeforeClass
+  public static void setUp() throws Exception {}
+
+  @Test
+  public void testBreakInMainClass() throws Throwable {
+    boolean minifiedNames = (minificationEnabled && !writeProguardMap);
+    final String className = "Minified";
+    final String methodName = minifiedNames ? "a" : "test";
+    final String signature = "()V";
+    final String innerClassName = minifiedNames ? "a" : "Minified$Inner";
+    final String innerMethodName = minifiedNames ? "a" : "innerTest";
+    final String innerSignature = "()I";
+    runDebugTestR8(
+        className,
+        breakpoint(className, methodName, signature),
+        run(),
+        checkMethod(className, methodName, signature),
+        checkLine(SOURCE_FILE, 14),
+        stepOver(),
+        checkMethod(className, methodName, signature),
+        checkLine(SOURCE_FILE, 15),
+        stepInto(),
+        checkMethod(innerClassName, innerMethodName, innerSignature),
+        checkLine(SOURCE_FILE, 8),
+        run());
+  }
+
+  @Test
+  public void testBreakInPossiblyRenamedClass() throws Throwable {
+    boolean minifiedNames = (minificationEnabled && !writeProguardMap);
+    final String className = "Minified";
+    final String innerClassName = minifiedNames ? "a" : "Minified$Inner";
+    final String innerMethodName = minifiedNames ? "a" : "innerTest";
+    final String innerSignature = "()I";
+    runDebugTestR8(
+        className,
+        breakpoint(innerClassName, innerMethodName, innerSignature),
+        run(),
+        checkMethod(innerClassName, innerMethodName, innerSignature),
+        checkLine(SOURCE_FILE, 8),
+        run());
+  }
+}