diff --git a/src/test/java/com/android/tools/r8/debug/ArrayDimensionGreaterThanSevenTest.java b/src/test/java/com/android/tools/r8/debug/ArrayDimensionGreaterThanSevenTest.java
new file mode 100644
index 0000000..68277dd
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/debug/ArrayDimensionGreaterThanSevenTest.java
@@ -0,0 +1,41 @@
+// 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 ArrayDimensionGreaterThanSevenTest {
+
+  public static float foo(int x) {
+    try {
+      float[] fs1 = new float[] {42f};
+      float[][] fs2 = new float[][] {fs1};
+      float[][][] fs3 = new float[][][] {fs2};
+      float[][][][] fs4 = new float[][][][] {fs3};
+      float[][][][][] fs5 = new float[][][][][] {fs4};
+      float[][][][][][] fs6 = new float[][][][][][] {fs5};
+      float[][][][][][][] fs7 = new float[][][][][][][] {fs6};
+      float[][][][][][][][] fs8 = new float[][][][][][][][] {fs7};
+      while (x-- > 0) {
+        try {
+          fs8 = x == 0 ? fs8 : null;
+          fs7 = x == 1 ? fs8[1] : fs8[0];
+          fs6 = x == 2 ? fs7[1] : fs7[0];
+          fs5 = x == 3 ? fs6[1] : fs6[0];
+          fs4 = x == 4 ? fs5[1] : fs5[0];
+          fs3 = x == 5 ? fs4[1] : fs4[0];
+          fs2 = x == 6 ? fs3[1] : fs3[0];
+          fs1 = x == 7 ? fs2[1] : fs2[0];
+        } catch (NullPointerException e) {
+          System.out.println("null pointer");
+        }
+      }
+    } catch (RuntimeException e) {
+      return -1f;
+    }
+    return 42;
+  }
+
+  public static void main(String[] args) {
+    System.out.println(foo(args.length + 1));
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/debug/ArrayDimensionGreaterThanSevenTestDump.java b/src/test/java/com/android/tools/r8/debug/ArrayDimensionGreaterThanSevenTestDump.java
new file mode 100644
index 0000000..5cd652d
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/debug/ArrayDimensionGreaterThanSevenTestDump.java
@@ -0,0 +1,590 @@
+package com.android.tools.r8.debug;
+
+import org.objectweb.asm.AnnotationVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+public class ArrayDimensionGreaterThanSevenTestDump implements Opcodes {
+
+  public static byte[] dump() throws Exception {
+
+    ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
+    FieldVisitor fv;
+    MethodVisitor mv;
+    AnnotationVisitor av0;
+
+    cw.visit(
+        V1_8,
+        ACC_PUBLIC + ACC_SUPER,
+        "com/android/tools/r8/debug/ArrayDimensionGreaterThanSevenTest",
+        null,
+        "java/lang/Object",
+        null);
+
+    {
+      mv = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
+      mv.visitCode();
+      mv.visitVarInsn(ALOAD, 0);
+      mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+      mv.visitInsn(RETURN);
+      mv.visitMaxs(1, 1);
+      mv.visitEnd();
+    }
+    {
+      mv = cw.visitMethod(ACC_PUBLIC + ACC_STATIC, "foo", "(I)F", null, null);
+      mv.visitCode();
+      Label l0 = new Label();
+      Label l1 = new Label();
+      Label l2 = new Label();
+      mv.visitTryCatchBlock(l0, l1, l2, "java/lang/NullPointerException");
+      Label l3 = new Label();
+      Label l4 = new Label();
+      Label l5 = new Label();
+      mv.visitTryCatchBlock(l3, l4, l5, "java/lang/RuntimeException");
+      mv.visitLabel(l3);
+      mv.visitInsn(ICONST_1);
+      mv.visitIntInsn(NEWARRAY, T_FLOAT);
+      mv.visitInsn(DUP);
+      mv.visitInsn(ICONST_0);
+      mv.visitLdcInsn(new Float("42.0"));
+      mv.visitInsn(FASTORE);
+      mv.visitVarInsn(ASTORE, 1);
+      mv.visitInsn(ICONST_1);
+      mv.visitTypeInsn(ANEWARRAY, "[F");
+      mv.visitInsn(DUP);
+      mv.visitInsn(ICONST_0);
+      mv.visitVarInsn(ALOAD, 1);
+      mv.visitInsn(AASTORE);
+      mv.visitVarInsn(ASTORE, 2);
+      mv.visitInsn(ICONST_1);
+      mv.visitTypeInsn(ANEWARRAY, "[[F");
+      mv.visitInsn(DUP);
+      mv.visitInsn(ICONST_0);
+      mv.visitVarInsn(ALOAD, 2);
+      mv.visitInsn(AASTORE);
+      mv.visitVarInsn(ASTORE, 3);
+      mv.visitInsn(ICONST_1);
+      mv.visitTypeInsn(ANEWARRAY, "[[[F");
+      mv.visitInsn(DUP);
+      mv.visitInsn(ICONST_0);
+      mv.visitVarInsn(ALOAD, 3);
+      mv.visitInsn(AASTORE);
+      mv.visitVarInsn(ASTORE, 4);
+      mv.visitInsn(ICONST_1);
+      mv.visitTypeInsn(ANEWARRAY, "[[[[F");
+      mv.visitInsn(DUP);
+      mv.visitInsn(ICONST_0);
+      mv.visitVarInsn(ALOAD, 4);
+      mv.visitInsn(AASTORE);
+      mv.visitVarInsn(ASTORE, 5);
+      mv.visitInsn(ICONST_1);
+      mv.visitTypeInsn(ANEWARRAY, "[[[[[F");
+      mv.visitInsn(DUP);
+      mv.visitInsn(ICONST_0);
+      mv.visitVarInsn(ALOAD, 5);
+      mv.visitInsn(AASTORE);
+      mv.visitVarInsn(ASTORE, 6);
+      mv.visitInsn(ICONST_1);
+      mv.visitTypeInsn(ANEWARRAY, "[[[[[[F");
+      mv.visitInsn(DUP);
+      mv.visitInsn(ICONST_0);
+      mv.visitVarInsn(ALOAD, 6);
+      mv.visitInsn(AASTORE);
+      mv.visitVarInsn(ASTORE, 7);
+      mv.visitInsn(ICONST_1);
+      mv.visitTypeInsn(ANEWARRAY, "[[[[[[[F");
+      mv.visitInsn(DUP);
+      mv.visitInsn(ICONST_0);
+      mv.visitVarInsn(ALOAD, 7);
+      mv.visitInsn(AASTORE);
+      mv.visitVarInsn(ASTORE, 8);
+      Label l6 = new Label();
+      mv.visitLabel(l6);
+      // mv.visitFrame(Opcodes.F_FULL, 9, new Object[] {Opcodes.INTEGER, "[F", "[[F", "[[[F",
+      // "[[[[F", "[[[[[F", "[[[[[[F", "[[[[[[[F", "[[[[[[[[F"}, 0, new Object[] {});
+      mv.visitFrame(
+          Opcodes.F_NEW,
+          9,
+          new Object[] {
+            Opcodes.INTEGER,
+            "[F",
+            "[[F",
+            "[[[F",
+            "[[[[F",
+            "[[[[[F",
+            "[[[[[[F",
+            "[[[[[[[F",
+            "[[[[[[[[F"
+          },
+          0,
+          new Object[] {});
+      mv.visitVarInsn(ILOAD, 0);
+      mv.visitIincInsn(0, -1);
+      mv.visitJumpInsn(IFLE, l4);
+      mv.visitLabel(l0);
+      mv.visitVarInsn(ILOAD, 0);
+      Label l7 = new Label();
+      mv.visitJumpInsn(IFNE, l7);
+      mv.visitVarInsn(ALOAD, 8);
+      Label l8 = new Label();
+      mv.visitJumpInsn(GOTO, l8);
+      mv.visitLabel(l7);
+      // mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
+      mv.visitFrame(
+          Opcodes.F_NEW,
+          9,
+          new Object[] {
+            Opcodes.INTEGER,
+            "[F",
+            "[[F",
+            "[[[F",
+            "[[[[F",
+            "[[[[[F",
+            "[[[[[[F",
+            "[[[[[[[F",
+            "[[[[[[[[F"
+          },
+          0,
+          new Object[] {});
+      mv.visitInsn(ACONST_NULL);
+      mv.visitTypeInsn(CHECKCAST, "[[[[[[[[F");
+      mv.visitLabel(l8);
+      // mv.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[] {"[[[[[[[[F"});
+      mv.visitFrame(
+          Opcodes.F_NEW,
+          9,
+          new Object[] {
+            Opcodes.INTEGER,
+            "[F",
+            "[[F",
+            "[[[F",
+            "[[[[F",
+            "[[[[[F",
+            "[[[[[[F",
+            "[[[[[[[F",
+            "[[[[[[[[F"
+          },
+          1,
+          new Object[] {"[[[[[[[[F"});
+      mv.visitVarInsn(ASTORE, 8);
+      mv.visitVarInsn(ILOAD, 0);
+      mv.visitInsn(ICONST_1);
+      Label l9 = new Label();
+      mv.visitJumpInsn(IF_ICMPNE, l9);
+      mv.visitVarInsn(ALOAD, 8);
+      mv.visitInsn(ICONST_1);
+      mv.visitInsn(AALOAD);
+      Label l10 = new Label();
+      mv.visitJumpInsn(GOTO, l10);
+      mv.visitLabel(l9);
+      // mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
+      mv.visitFrame(
+          Opcodes.F_NEW,
+          9,
+          new Object[] {
+            Opcodes.INTEGER,
+            "[F",
+            "[[F",
+            "[[[F",
+            "[[[[F",
+            "[[[[[F",
+            "[[[[[[F",
+            "[[[[[[[F",
+            "[[[[[[[[F"
+          },
+          0,
+          new Object[] {});
+      mv.visitVarInsn(ALOAD, 8);
+      mv.visitInsn(ICONST_0);
+      mv.visitInsn(AALOAD);
+      mv.visitLabel(l10);
+      // mv.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[] {"[[[[[[[F"});
+      mv.visitFrame(
+          Opcodes.F_NEW,
+          9,
+          new Object[] {
+            Opcodes.INTEGER,
+            "[F",
+            "[[F",
+            "[[[F",
+            "[[[[F",
+            "[[[[[F",
+            "[[[[[[F",
+            "[[[[[[[F",
+            "[[[[[[[[F"
+          },
+          1,
+          new Object[] {"[[[[[[[F"});
+      mv.visitVarInsn(ASTORE, 7);
+      mv.visitVarInsn(ILOAD, 0);
+      mv.visitInsn(ICONST_2);
+      Label l11 = new Label();
+      mv.visitJumpInsn(IF_ICMPNE, l11);
+      mv.visitVarInsn(ALOAD, 7);
+      mv.visitInsn(ICONST_1);
+      mv.visitInsn(AALOAD);
+      Label l12 = new Label();
+      mv.visitJumpInsn(GOTO, l12);
+      mv.visitLabel(l11);
+      // mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
+      mv.visitFrame(
+          Opcodes.F_NEW,
+          9,
+          new Object[] {
+            Opcodes.INTEGER,
+            "[F",
+            "[[F",
+            "[[[F",
+            "[[[[F",
+            "[[[[[F",
+            "[[[[[[F",
+            "[[[[[[[F",
+            "[[[[[[[[F"
+          },
+          0,
+          new Object[] {});
+      mv.visitVarInsn(ALOAD, 7);
+      mv.visitInsn(ICONST_0);
+      mv.visitInsn(AALOAD);
+      mv.visitLabel(l12);
+      // mv.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[] {"[[[[[[F"});
+      mv.visitFrame(
+          Opcodes.F_NEW,
+          9,
+          new Object[] {
+            Opcodes.INTEGER,
+            "[F",
+            "[[F",
+            "[[[F",
+            "[[[[F",
+            "[[[[[F",
+            "[[[[[[F",
+            "[[[[[[[F",
+            "[[[[[[[[F"
+          },
+          1,
+          new Object[] {"[[[[[[F"});
+      mv.visitVarInsn(ASTORE, 6);
+      mv.visitVarInsn(ILOAD, 0);
+      mv.visitInsn(ICONST_3);
+      Label l13 = new Label();
+      mv.visitJumpInsn(IF_ICMPNE, l13);
+      mv.visitVarInsn(ALOAD, 6);
+      mv.visitInsn(ICONST_1);
+      mv.visitInsn(AALOAD);
+      Label l14 = new Label();
+      mv.visitJumpInsn(GOTO, l14);
+      mv.visitLabel(l13);
+      // mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
+      mv.visitFrame(
+          Opcodes.F_NEW,
+          9,
+          new Object[] {
+            Opcodes.INTEGER,
+            "[F",
+            "[[F",
+            "[[[F",
+            "[[[[F",
+            "[[[[[F",
+            "[[[[[[F",
+            "[[[[[[[F",
+            "[[[[[[[[F"
+          },
+          0,
+          new Object[] {});
+      mv.visitVarInsn(ALOAD, 6);
+      mv.visitInsn(ICONST_0);
+      mv.visitInsn(AALOAD);
+      mv.visitLabel(l14);
+      // mv.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[] {"[[[[[F"});
+      mv.visitFrame(
+          Opcodes.F_NEW,
+          9,
+          new Object[] {
+            Opcodes.INTEGER,
+            "[F",
+            "[[F",
+            "[[[F",
+            "[[[[F",
+            "[[[[[F",
+            "[[[[[[F",
+            "[[[[[[[F",
+            "[[[[[[[[F"
+          },
+          1,
+          new Object[] {"[[[[[F"});
+      mv.visitVarInsn(ASTORE, 5);
+      mv.visitVarInsn(ILOAD, 0);
+      mv.visitInsn(ICONST_4);
+      Label l15 = new Label();
+      mv.visitJumpInsn(IF_ICMPNE, l15);
+      mv.visitVarInsn(ALOAD, 5);
+      mv.visitInsn(ICONST_1);
+      mv.visitInsn(AALOAD);
+      Label l16 = new Label();
+      mv.visitJumpInsn(GOTO, l16);
+      mv.visitLabel(l15);
+      // mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
+      mv.visitFrame(
+          Opcodes.F_NEW,
+          9,
+          new Object[] {
+            Opcodes.INTEGER,
+            "[F",
+            "[[F",
+            "[[[F",
+            "[[[[F",
+            "[[[[[F",
+            "[[[[[[F",
+            "[[[[[[[F",
+            "[[[[[[[[F"
+          },
+          0,
+          new Object[] {});
+      mv.visitVarInsn(ALOAD, 5);
+      mv.visitInsn(ICONST_0);
+      mv.visitInsn(AALOAD);
+      mv.visitLabel(l16);
+      // mv.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[] {"[[[[F"});
+      mv.visitFrame(
+          Opcodes.F_NEW,
+          9,
+          new Object[] {
+            Opcodes.INTEGER,
+            "[F",
+            "[[F",
+            "[[[F",
+            "[[[[F",
+            "[[[[[F",
+            "[[[[[[F",
+            "[[[[[[[F",
+            "[[[[[[[[F"
+          },
+          1,
+          new Object[] {"[[[[F"});
+      mv.visitVarInsn(ASTORE, 4);
+      mv.visitVarInsn(ILOAD, 0);
+      mv.visitInsn(ICONST_5);
+      Label l17 = new Label();
+      mv.visitJumpInsn(IF_ICMPNE, l17);
+      mv.visitVarInsn(ALOAD, 4);
+      mv.visitInsn(ICONST_1);
+      mv.visitInsn(AALOAD);
+      Label l18 = new Label();
+      mv.visitJumpInsn(GOTO, l18);
+      mv.visitLabel(l17);
+      // mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
+      mv.visitFrame(
+          Opcodes.F_NEW,
+          9,
+          new Object[] {
+            Opcodes.INTEGER,
+            "[F",
+            "[[F",
+            "[[[F",
+            "[[[[F",
+            "[[[[[F",
+            "[[[[[[F",
+            "[[[[[[[F",
+            "[[[[[[[[F"
+          },
+          0,
+          new Object[] {});
+      mv.visitVarInsn(ALOAD, 4);
+      mv.visitInsn(ICONST_0);
+      mv.visitInsn(AALOAD);
+      mv.visitLabel(l18);
+      // mv.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[] {"[[[F"});
+      mv.visitFrame(
+          Opcodes.F_NEW,
+          9,
+          new Object[] {
+            Opcodes.INTEGER,
+            "[F",
+            "[[F",
+            "[[[F",
+            "[[[[F",
+            "[[[[[F",
+            "[[[[[[F",
+            "[[[[[[[F",
+            "[[[[[[[[F"
+          },
+          1,
+          new Object[] {"[[[F"});
+      mv.visitVarInsn(ASTORE, 3);
+      mv.visitVarInsn(ILOAD, 0);
+      mv.visitIntInsn(BIPUSH, 6);
+      Label l19 = new Label();
+      mv.visitJumpInsn(IF_ICMPNE, l19);
+      mv.visitVarInsn(ALOAD, 3);
+      mv.visitInsn(ICONST_1);
+      mv.visitInsn(AALOAD);
+      Label l20 = new Label();
+      mv.visitJumpInsn(GOTO, l20);
+      mv.visitLabel(l19);
+      // mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
+      mv.visitFrame(
+          Opcodes.F_NEW,
+          9,
+          new Object[] {
+            Opcodes.INTEGER,
+            "[F",
+            "[[F",
+            "[[[F",
+            "[[[[F",
+            "[[[[[F",
+            "[[[[[[F",
+            "[[[[[[[F",
+            "[[[[[[[[F"
+          },
+          0,
+          new Object[] {});
+      mv.visitVarInsn(ALOAD, 3);
+      mv.visitInsn(ICONST_0);
+      mv.visitInsn(AALOAD);
+      mv.visitLabel(l20);
+      // mv.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[] {"[[F"});
+      mv.visitFrame(
+          Opcodes.F_NEW,
+          9,
+          new Object[] {
+            Opcodes.INTEGER,
+            "[F",
+            "[[F",
+            "[[[F",
+            "[[[[F",
+            "[[[[[F",
+            "[[[[[[F",
+            "[[[[[[[F",
+            "[[[[[[[[F"
+          },
+          1,
+          new Object[] {"[[F"});
+      mv.visitVarInsn(ASTORE, 2);
+      mv.visitVarInsn(ILOAD, 0);
+      mv.visitIntInsn(BIPUSH, 7);
+      Label l21 = new Label();
+      mv.visitJumpInsn(IF_ICMPNE, l21);
+      mv.visitVarInsn(ALOAD, 2);
+      mv.visitInsn(ICONST_1);
+      mv.visitInsn(AALOAD);
+      Label l22 = new Label();
+      mv.visitJumpInsn(GOTO, l22);
+      mv.visitLabel(l21);
+      // mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
+      mv.visitFrame(
+          Opcodes.F_NEW,
+          9,
+          new Object[] {
+            Opcodes.INTEGER,
+            "[F",
+            "[[F",
+            "[[[F",
+            "[[[[F",
+            "[[[[[F",
+            "[[[[[[F",
+            "[[[[[[[F",
+            "[[[[[[[[F"
+          },
+          0,
+          new Object[] {});
+      mv.visitVarInsn(ALOAD, 2);
+      mv.visitInsn(ICONST_0);
+      mv.visitInsn(AALOAD);
+      mv.visitLabel(l22);
+      // mv.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[] {"[F"});
+      mv.visitFrame(
+          Opcodes.F_NEW,
+          9,
+          new Object[] {
+            Opcodes.INTEGER,
+            "[F",
+            "[[F",
+            "[[[F",
+            "[[[[F",
+            "[[[[[F",
+            "[[[[[[F",
+            "[[[[[[[F",
+            "[[[[[[[[F"
+          },
+          1,
+          new Object[] {"[F"});
+      mv.visitVarInsn(ASTORE, 1);
+      mv.visitLabel(l1);
+      mv.visitJumpInsn(GOTO, l6);
+      mv.visitLabel(l2);
+      // mv.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[]
+      // {"java/lang/NullPointerException"});
+      mv.visitFrame(
+          Opcodes.F_NEW,
+          9,
+          new Object[] {
+            Opcodes.INTEGER,
+            "[F",
+            "[[F",
+            "[[[F",
+            "[[[[F",
+            "[[[[[F",
+            "[[[[[[F",
+            "[[[[[[[F",
+            "[[[[[[[[F"
+          },
+          1,
+          new Object[] {"java/lang/NullPointerException"});
+      mv.visitVarInsn(ASTORE, 9);
+      mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
+      mv.visitLdcInsn("null pointer");
+      mv.visitMethodInsn(
+          INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
+      mv.visitJumpInsn(GOTO, l6);
+      mv.visitLabel(l4);
+      // mv.visitFrame(Opcodes.F_FULL, 1, new Object[] {Opcodes.INTEGER}, 0, new Object[] {});
+      mv.visitFrame(Opcodes.F_NEW, 1, new Object[] {Opcodes.INTEGER}, 0, new Object[] {});
+      Label l23 = new Label();
+      mv.visitJumpInsn(GOTO, l23);
+      mv.visitLabel(l5);
+      // mv.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[] {"java/lang/RuntimeException"});
+      mv.visitFrame(
+          Opcodes.F_NEW,
+          1,
+          new Object[] {Opcodes.INTEGER},
+          1,
+          new Object[] {"java/lang/RuntimeException"});
+      mv.visitVarInsn(ASTORE, 1);
+      mv.visitLdcInsn(new Float("-1.0"));
+      mv.visitInsn(FRETURN);
+      mv.visitLabel(l23);
+      // mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
+      mv.visitFrame(Opcodes.F_NEW, 1, new Object[] {Opcodes.INTEGER}, 0, new Object[] {});
+      mv.visitLdcInsn(new Float("42.0"));
+      mv.visitInsn(FRETURN);
+      mv.visitMaxs(4, 10);
+      mv.visitEnd();
+    }
+    {
+      mv = cw.visitMethod(ACC_PUBLIC + ACC_STATIC, "main", "([Ljava/lang/String;)V", null, null);
+      mv.visitCode();
+      mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
+      mv.visitVarInsn(ALOAD, 0);
+      mv.visitInsn(ARRAYLENGTH);
+      mv.visitInsn(ICONST_1);
+      mv.visitInsn(IADD);
+      mv.visitMethodInsn(
+          INVOKESTATIC,
+          "com/android/tools/r8/debug/ArrayDimensionGreaterThanSevenTest",
+          "foo",
+          "(I)F",
+          false);
+      mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(F)V", false);
+      mv.visitInsn(RETURN);
+      mv.visitMaxs(3, 1);
+      mv.visitEnd();
+    }
+    cw.visitEnd();
+
+    return cw.toByteArray();
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/debug/ArrayDimensionGreaterThanSevenTestRunner.java b/src/test/java/com/android/tools/r8/debug/ArrayDimensionGreaterThanSevenTestRunner.java
new file mode 100644
index 0000000..7866e1b
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/debug/ArrayDimensionGreaterThanSevenTestRunner.java
@@ -0,0 +1,82 @@
+// 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.hamcrest.CoreMatchers.containsString;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+
+import com.android.tools.r8.ClassFileConsumer.ArchiveConsumer;
+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.ProcessResult;
+import com.android.tools.r8.debug.DebugTestBase.JUnit3Wrapper.DebuggeeState;
+import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.InternalOptions;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.function.Consumer;
+import java.util.stream.Stream;
+import org.junit.Ignore;
+import org.junit.Test;
+
+public class ArrayDimensionGreaterThanSevenTestRunner extends DebugTestBase {
+
+  private static final Class CLASS = ArrayDimensionGreaterThanSevenTest.class;
+  private static final String NAME = CLASS.getCanonicalName();
+
+  private DebugTestConfig getR8CfConfig(String s, Consumer<InternalOptions> optionsConsumer)
+      throws IOException, com.android.tools.r8.CompilationFailedException {
+    Path cfOut = temp.getRoot().toPath().resolve(s);
+    ToolHelper.runR8(
+        R8Command.builder()
+            .addClassProgramData(ToolHelper.getClassAsBytes(CLASS), Origin.unknown())
+            .setMode(CompilationMode.DEBUG)
+            .setOutput(cfOut, OutputMode.ClassFile)
+            .build(),
+        optionsConsumer);
+    return new CfDebugTestConfig(cfOut);
+  }
+
+  private Stream<DebuggeeState> createStream(DebugTestConfig config) throws Exception {
+    return streamDebugTest(config, NAME, ANDROID_FILTER);
+  }
+
+  @Test
+  @Ignore("b/111296969")
+  // Once R8 does not use expanded frames this can be enabled again.
+  public void test() throws Exception {
+    DebugTestConfig cfConfig = new CfDebugTestConfig().addPaths(ToolHelper.getClassPathForTests());
+    DebugTestConfig d8Config = new D8DebugTestConfig().compileAndAddClasses(temp, CLASS);
+    DebugTestConfig r8JarConfig =
+        getR8CfConfig("r8jar.jar", options -> options.enableCfFrontend = false);
+    DebugTestConfig r8CfConfig =
+        getR8CfConfig("r8cf.jar", options -> options.enableCfFrontend = true);
+    new DebugStreamComparator()
+        .add("CF", createStream(cfConfig))
+        .add("R8/CF", createStream(r8CfConfig))
+        .add("R8/Jar", createStream(r8JarConfig))
+        .add("D8", createStream(d8Config))
+        .compare();
+  }
+
+  @Test
+  // Verify that ASM fails when using expanded frames directly.
+  // See b/111296969
+  public void runTestOnAsmDump() throws Exception {
+    Path out = temp.getRoot().toPath().resolve("out.jar");
+    ArchiveConsumer consumer = new ArchiveConsumer(out);
+    consumer.accept(
+        ArrayDimensionGreaterThanSevenTestDump.dump(),
+        DescriptorUtils.javaTypeToDescriptor(NAME),
+        null);
+    consumer.finished(null);
+    ProcessResult result = ToolHelper.runJava(out, NAME);
+    assertEquals("Expected ASM to fail when using visitFrame(F_NEW, ...)", 1, result.exitCode);
+    assertThat(result.stderr, containsString("java.lang.NoClassDefFoundError: F"));
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/debug/DebugStreamComparator.java b/src/test/java/com/android/tools/r8/debug/DebugStreamComparator.java
index eb85a7c..3a83e30 100644
--- a/src/test/java/com/android/tools/r8/debug/DebugStreamComparator.java
+++ b/src/test/java/com/android/tools/r8/debug/DebugStreamComparator.java
@@ -214,7 +214,8 @@
       try {
         if (done) {
           assertTrue(
-              "Not all streams completed at the same time",
+              "Not all streams completed at the same time. "
+                  + "Set 'DebugTestBase.DEBUG_TEST = true' to aid in diagnosing the issue.",
               states.stream().allMatch(Objects::isNull));
           return;
         } else {