diff --git a/src/main/java/com/android/tools/r8/Disassemble.java b/src/main/java/com/android/tools/r8/Disassemble.java
index e51e4d4..4f64416 100644
--- a/src/main/java/com/android/tools/r8/Disassemble.java
+++ b/src/main/java/com/android/tools/r8/Disassemble.java
@@ -32,6 +32,7 @@
       private Path outputPath = null;
       private Path proguardMapFile = null;
       private boolean useSmali = false;
+      private boolean allInfo = false;
 
       @Override
       Builder self() {
@@ -52,6 +53,11 @@
         return this;
       }
 
+      public Builder setAllInfo(boolean allInfo) {
+        this.allInfo = allInfo;
+        return this;
+      }
+
       public Builder setUseSmali(boolean useSmali) {
         this.useSmali = useSmali;
         return this;
@@ -67,6 +73,7 @@
             getAppBuilder().build(),
             getOutputPath(),
             proguardMapFile == null ? null : StringResource.fromFile(proguardMapFile),
+            allInfo,
             useSmali);
       }
     }
@@ -75,6 +82,7 @@
         "Usage: disasm [options] <input-files>",
         " where <input-files> are dex files",
         " and options are:",
+        "  --all                   # Include all information in disassembly.",
         "  --smali                 # Disassemble using smali syntax.",
         "  --pg-map <file>         # Proguard map <file> for mapping names.",
         "  --output                # Specify a file or directory to write to.",
@@ -82,6 +90,7 @@
         "  --help                  # Print this message."));
 
 
+    private final boolean allInfo;
     private final boolean useSmali;
 
     public static Builder builder() {
@@ -103,6 +112,8 @@
           builder.setPrintHelp(true);
         } else if (arg.equals("--version")) {
           builder.setPrintVersion(true);
+          } else if (arg.equals("--all")) {
+          builder.setAllInfo(true);
         } else if (arg.equals("--smali")) {
           builder.setUseSmali(true);
         } else if (arg.equals("--pg-map")) {
@@ -121,10 +132,12 @@
     }
 
     private DisassembleCommand(
-        AndroidApp inputApp, Path outputPath, StringResource proguardMap, boolean useSmali) {
+        AndroidApp inputApp, Path outputPath, StringResource proguardMap,
+        boolean allInfo, boolean useSmali) {
       super(inputApp);
       this.outputPath = outputPath;
       this.proguardMap = proguardMap;
+      this.allInfo = allInfo;
       this.useSmali = useSmali;
     }
 
@@ -132,6 +145,7 @@
       super(printHelp, printVersion);
       outputPath = null;
       proguardMap = null;
+      allInfo = false;
       useSmali = false;
     }
 
@@ -177,7 +191,7 @@
           new ApplicationReader(app, options, timing).read(command.proguardMap, executor);
       DexByteCodeWriter writer = command.useSmali()
           ? new SmaliWriter(application, options)
-          : new AssemblyWriter(application, options);
+          : new AssemblyWriter(application, options, command.allInfo);
       if (command.getOutputPath() != null) {
         writer.write(command.getOutputPath());
       } else {
diff --git a/src/main/java/com/android/tools/r8/graph/AssemblyWriter.java b/src/main/java/com/android/tools/r8/graph/AssemblyWriter.java
index 50ff578..63a2958 100644
--- a/src/main/java/com/android/tools/r8/graph/AssemblyWriter.java
+++ b/src/main/java/com/android/tools/r8/graph/AssemblyWriter.java
@@ -4,13 +4,21 @@
 package com.android.tools.r8.graph;
 
 import com.android.tools.r8.naming.ClassNameMapper;
+import com.android.tools.r8.naming.MemberNaming.FieldSignature;
 import com.android.tools.r8.utils.InternalOptions;
 import java.io.PrintStream;
 
 public class AssemblyWriter extends DexByteCodeWriter {
 
-  public AssemblyWriter(DexApplication application, InternalOptions options) {
+  private final boolean writeAllClassInfo;
+  private final boolean writeFields;
+  private final boolean writeAnnotations;
+
+  public AssemblyWriter(DexApplication application, InternalOptions options, boolean allInfo) {
     super(application, options);
+    this.writeAllClassInfo = allInfo;
+    this.writeFields = allInfo;
+    this.writeAnnotations = allInfo;
   }
 
   @Override
@@ -28,12 +36,43 @@
     }
     ps.println("# Bytecode for");
     ps.println("# Class: '" + clazzName + "'");
+    if (writeAllClassInfo) {
+      writeAnnotations(clazz.annotations, ps);
+      ps.println("# Flags: '" + clazz.accessFlags + "'");
+      if (clazz.superType != application.dexItemFactory.objectType) {
+        ps.println("# Extends: '" + clazz.superType.toSourceString() + "'");
+      }
+      for (DexType value : clazz.interfaces.values) {
+        ps.println("# Implements: '" + value.toSourceString() + "'");
+      }
+    }
     ps.println();
   }
 
   @Override
+  void writeFieldsHeader(DexProgramClass clazz, PrintStream ps) {
+    if (writeFields) {
+      ps.println("#");
+      ps.println("# Fields:");
+      ps.println("#");
+    }
+  }
+
+  @Override
   void writeField(DexEncodedField field, PrintStream ps) {
-    // Not implemented, yet.
+    if (writeFields) {
+      ClassNameMapper naming = application.getProguardMap();
+      FieldSignature fieldSignature = naming != null
+          ? naming.originalSignatureOf(field.field)
+          : FieldSignature.fromDexField(field.field);
+      writeAnnotations(field.annotations, ps);
+      ps.println(fieldSignature);
+    }
+  }
+
+  @Override
+  void writeFieldsFooter(DexProgramClass clazz, PrintStream ps) {
+    ps.println();
   }
 
   @Override
@@ -44,6 +83,7 @@
         : method.method.name.toString();
     ps.println("#");
     ps.println("# Method: '" + methodName + "':");
+    writeAnnotations(method.annotations, ps);
     ps.println("#");
     ps.println();
     Code code = method.getCode();
@@ -52,6 +92,18 @@
     }
   }
 
+  private void writeAnnotations(DexAnnotationSet annotations, PrintStream ps) {
+    if (writeAnnotations) {
+      if (!annotations.isEmpty()) {
+        ps.println("# Annotations:");
+        for (DexAnnotation annotation : annotations.annotations) {
+          ps.print("#   ");
+          ps.println(annotation);
+        }
+      }
+    }
+  }
+
   @Override
   void writeClassFooter(DexProgramClass clazz, PrintStream ps) {
 
diff --git a/src/main/java/com/android/tools/r8/graph/DexByteCodeWriter.java b/src/main/java/com/android/tools/r8/graph/DexByteCodeWriter.java
index 025a502..21900a01 100644
--- a/src/main/java/com/android/tools/r8/graph/DexByteCodeWriter.java
+++ b/src/main/java/com/android/tools/r8/graph/DexByteCodeWriter.java
@@ -82,8 +82,12 @@
 
   private void writeClass(DexProgramClass clazz, PrintStream ps) {
     writeClassHeader(clazz, ps);
+    writeFieldsHeader(clazz, ps);
     clazz.forEachField(field -> writeField(field, ps));
+    writeFieldsFooter(clazz, ps);
+    writeMethodsHeader(clazz, ps);
     clazz.forEachMethod(method -> writeMethod(method, ps));
+    writeMethodsFooter(clazz, ps);
     writeClassFooter(clazz, ps);
   }
 
@@ -91,9 +95,25 @@
 
   abstract void writeClassHeader(DexProgramClass clazz, PrintStream ps);
 
+  void writeFieldsHeader(DexProgramClass clazz, PrintStream ps) {
+    // Do nothing.
+  }
+
   abstract void writeField(DexEncodedField field, PrintStream ps);
 
+  void writeFieldsFooter(DexProgramClass clazz, PrintStream ps) {
+    // Do nothing.
+  }
+
+  void writeMethodsHeader(DexProgramClass clazz, PrintStream ps) {
+    // Do nothing.
+  }
+
   abstract void writeMethod(DexEncodedMethod method, PrintStream ps);
 
+  void writeMethodsFooter(DexProgramClass clazz, PrintStream ps) {
+    // Do nothing.
+  }
+
   abstract void writeClassFooter(DexProgramClass clazz, PrintStream ps);
 }
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 de85da5..6ec9e6e 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
@@ -1279,9 +1279,10 @@
     return false;
   }
 
-  private boolean longOverlappingLong(int register1, int register2) {
-    return register1 == register2 || register1 == (register2 + 1)
-        || (register1 + 1) == register2 || (register1 + 1) == (register2 + 1);
+  // Check if the two longs are half-overlapping, that is first register of one is the second
+  // register of the other.
+  private boolean longHalfOverlappingLong(int register1, int register2) {
+    return register1 == (register2 + 1) || (register1 + 1) == register2;
   }
 
   private boolean isLongResultOverlappingLongOperands(
@@ -1297,7 +1298,8 @@
     // The dalvik bug is actually only for overlap with the second operand, For now we
     // make sure that there is no overlap with either register of either operand. Some vendor
     // optimization have bees seen to need this more conservative check.
-    return longOverlappingLong(register, leftReg) || longOverlappingLong(register, rightReg);
+    return longHalfOverlappingLong(register, leftReg)
+        || longHalfOverlappingLong(register, rightReg);
   }
 
   // Intervals overlap a move exception interval if one of the splits of the intervals does.
diff --git a/src/main/java/com/android/tools/r8/naming/ClassNameMapper.java b/src/main/java/com/android/tools/r8/naming/ClassNameMapper.java
index 30a5418..5b908af 100644
--- a/src/main/java/com/android/tools/r8/naming/ClassNameMapper.java
+++ b/src/main/java/com/android/tools/r8/naming/ClassNameMapper.java
@@ -110,9 +110,9 @@
     return (MethodSignature) canonicalizeSignature(signature);
   }
 
-  public Signature getRenamedFieldSignature(DexField field) {
+  public FieldSignature getRenamedFieldSignature(DexField field) {
     String type = deobfuscateType(field.type.toDescriptorString());
-    return canonicalizeSignature(new FieldSignature(field.name.toString(), type));
+    return (FieldSignature) canonicalizeSignature(new FieldSignature(field.name.toString(), type));
   }
 
   /**
@@ -231,6 +231,20 @@
     return memberNaming.signature;
   }
 
+  public FieldSignature originalSignatureOf(DexField field) {
+    String decoded = descriptorToJavaType(field.clazz.descriptor.toString());
+    FieldSignature memberSignature = getRenamedFieldSignature(field);
+    ClassNaming classNaming = getClassNaming(decoded);
+    if (classNaming == null) {
+      return memberSignature;
+    }
+    MemberNaming memberNaming = classNaming.lookup(memberSignature);
+    if (memberNaming == null) {
+      return memberSignature;
+    }
+    return (FieldSignature) memberNaming.signature;
+  }
+
   public String originalNameOf(DexType clazz) {
     return deobfuscateType(clazz.descriptor.toString());
   }
diff --git a/src/test/java/com/android/tools/r8/debug/LocalsLiveAtBlockEntryDebugTest.java b/src/test/java/com/android/tools/r8/debug/LocalsLiveAtBlockEntryDebugTest.java
new file mode 100644
index 0000000..36cdad0
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/debug/LocalsLiveAtBlockEntryDebugTest.java
@@ -0,0 +1,117 @@
+// 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 static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.jasmin.JasminBuilder;
+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.nio.file.Path;
+import java.util.Collections;
+import java.util.List;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+/**
+ * Test to check that locals that are introduced in a block that is not hit, still start in the
+ * block where they first become visible.
+ *
+ * <p>See b/75251251 or b/78617758
+ */
+public class LocalsLiveAtBlockEntryDebugTest extends DebugTestBase {
+
+  final String className = "LocalsLiveAtEntry";
+  final String sourcefile = className + ".j";
+  final String methodName = "test";
+
+  @Rule
+  public TemporaryFolder temp = ToolHelper.getTemporaryFolderForTest();
+
+  @Test
+  public void testCF() throws Throwable {
+    JasminBuilder builder = getBuilderForTest(className, methodName);
+    Path outdir = temp.newFolder().toPath();
+    builder.writeClassFiles(outdir);
+    CfDebugTestConfig config = new CfDebugTestConfig();
+    config.addPaths(outdir);
+    runTest(config);
+  }
+
+  @Test
+  @Ignore("b/78617758")
+  public void testD8() throws Throwable {
+    JasminBuilder builder = getBuilderForTest(className, methodName);
+    List<Path> outputs = builder.writeClassFiles(temp.newFolder().toPath());
+    runTest(new D8DebugTestConfig().compileAndAdd(temp, outputs));
+  }
+
+  private void runTest(DebugTestConfig config) throws Throwable {
+    DexInspector inspector =
+        new DexInspector(
+            (config instanceof CfDebugTestConfig)
+                ? Collections.singletonList(config.getPaths().get(1).resolve(className + ".class"))
+                : config.getPaths());
+    ClassSubject clazz = inspector.clazz(className);
+    MethodSubject method = clazz.method("void", methodName, ImmutableList.of("java.lang.Object"));
+    assertTrue(method.isPresent());
+    runDebugTest(
+        config,
+        className,
+        breakpoint(className, methodName),
+        run(),
+        checkLine(sourcefile, 1),
+        checkNoLocal("obj"),
+        stepOver(),
+        checkLine(sourcefile, 3),
+        checkLocal("obj"),
+        stepOver(),
+        checkLine(sourcefile, 100),
+        run());
+  }
+
+  private JasminBuilder getBuilderForTest(String testClassName, String testMethodName) {
+    JasminBuilder builder = new JasminBuilder();
+    JasminBuilder.ClassBuilder clazz = builder.addClass(testClassName);
+
+    clazz.addStaticMethod(
+        testMethodName,
+        ImmutableList.of("Ljava/lang/Object;"),
+        "V",
+        ".limit stack 2",
+        ".limit locals 3",
+        ".var 0 is obj L" + testClassName + "; from L1 to L3",
+        "L0:", // Preamble code that does not have any live locals (eg, no formals too!).
+        ".line 1",
+        " ldc 42",
+        " lookupswitch",
+        "   0: L1",
+        "   default: L2",
+        "L1:", // late introduction of formals.
+        ".line 2",
+        " aconst_null",
+        " pop",
+        "L2:", // target block with first visible location of locals.
+        ".line 3",
+        " aconst_null",
+        " pop",
+        " return",
+        "L3:");
+
+    clazz.addMainMethod(
+        ".limit stack 2",
+        ".limit locals 1",
+        ".line 100",
+        "aconst_null",
+        "invokestatic " + testClassName + "/" + testMethodName + "(Ljava/lang/Object;)V",
+        "return");
+
+    return builder;
+  }
+}