BCodeOpt buidling block: UnreachableCode

This bytecode transformer removes code that is unreachable.

Details in the documentation for scala.tools.nsc.backend.bcode.UnreachableCode

Author: magarciaEPFL

src/asm/scala/tools/asm/MethodWriter.java

@@ -37,7 +37,7 @@
  * @author Eric Bruneton
  * @author Eugene Kuleshov
  */
-class MethodWriter extends MethodVisitor {
+public class MethodWriter extends MethodVisitor {
 
     /**
      * Pseudo access flag used to denote constructors.
@@ -223,11 +223,19 @@ class MethodWriter extends MethodVisitor {
      */
     private int maxStack;
 
+    public int getMaxStack() {
+        return maxStack;
+    }
+
     /**
      * Maximum number of local variables for this method.
      */
     private int maxLocals;
 
+    public int getMaxLocals() {
+        return maxLocals;
+    }
+
     /**
      * Number of local variables in the current stack map frame.
      */

src/compiler/scala/tools/nsc/backend/bcode/UnreachableCode.java

@@ -0,0 +1,60 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2013 LAMP/EPFL
+ * @author  Martin Odersky
+ */
+
+package scala.tools.nsc.backend.bcode;
+
+import scala.tools.asm.tree.MethodNode;
+import scala.tools.asm.tree.AbstractInsnNode;
+import scala.tools.asm.tree.LabelNode;
+
+import scala.tools.asm.tree.analysis.Analyzer;
+import scala.tools.asm.tree.analysis.AnalyzerException;
+import scala.tools.asm.tree.analysis.Frame;
+import scala.tools.asm.tree.analysis.BasicInterpreter;
+import scala.tools.asm.tree.analysis.BasicValue;
+
+/**
+ * Detects and removes unreachable code.
+ *
+ * Should be used last in a transformation chain, before stack map frames are computed.
+ * The Java 6 verifier demands frames be available even for dead code.
+ * Those frames are tricky to compute, http://asm.ow2.org/doc/developer-guide.html#deadcode
+ * The problem is avoided altogether by not emitting unreachable code in the first place.
+ *
+ *  @author  Miguel Garcia, http://lamp.epfl.ch/~magarcia/ScalaCompilerCornerReloaded/
+ *  @version 1.0
+ *
+ */
+public class UnreachableCode {
+
+    /** after transform() has run, this field records whether
+     *  at least one pass of this transformer modified something. */
+    public boolean changed = false;
+
+    public void transform(final String owner, final MethodNode mnode) throws AnalyzerException {
+
+        changed = false;
+
+        Analyzer<BasicValue> a = new Analyzer<BasicValue>(new BasicInterpreter());
+        a.analyze(owner, mnode);
+
+        Frame<BasicValue>[] frames = a.getFrames();
+        AbstractInsnNode[]  insns  = mnode.instructions.toArray();
+
+        int i = 0;
+        while (i < insns.length) {
+          if (frames[i] == null &&
+              insns[i]  != null &&
+              !(insns[i] instanceof LabelNode)) {
+            mnode.instructions.remove(insns[i]);
+            changed = true;
+          }
+          i += 1;
+        }
+
+    }
+
+}
+

src/compiler/scala/tools/nsc/backend/bcode/Util.java

@@ -6,8 +6,13 @@
 
 package scala.tools.nsc.backend.bcode;
 
+import scala.tools.asm.ClassWriter;
+import scala.tools.asm.MethodWriter;
+
 import scala.tools.asm.tree.AbstractInsnNode;
 import scala.tools.asm.tree.LabelNode;
+import scala.tools.asm.tree.MethodNode;
+
 /**
  *  Utilities.
  *
@@ -33,5 +38,28 @@ public static AbstractInsnNode insnLabelledBy(final LabelNode label) {
         return labelled;
     }
 
+    // ------------------------------------------------------------------------
+    // maxLocals and maxStack
+    // ------------------------------------------------------------------------
+
+    /**
+     * In order to run Analyzer.analyze() on a method, its `maxLocals` should have been computed.
+     */
+    public static boolean isReadyForAnalyzer(final MethodNode mnode) {
+      return mnode.maxLocals != 0 || mnode.maxStack != 0;
+    }
+
+    /**
+     * In order to run Analyzer.analyze() on a method, its `maxLocals` should have been computed.
+     */
+    public static void computeMaxLocalsMaxStack(final MethodNode mnode) {
+        ClassWriter cw  = new ClassWriter(ClassWriter.COMPUTE_MAXS);
+        String[] excs   = mnode.exceptions.toArray(new String[0]);
+        MethodWriter mw = (MethodWriter)cw.visitMethod(mnode.access, mnode.name, mnode.desc, mnode.signature, excs);
+        mnode.accept(mw);
+        mnode.maxLocals = mw.getMaxLocals();
+        mnode.maxStack  = mw.getMaxStack();
+    }
+
 
 }

test/files/jvm/bcode_deadCode_unit_1/Test.scala

@@ -0,0 +1,55 @@
+import scala.tools.nsc.backend.bcode.UnreachableCode
+import scala.tools.nsc.backend.bcode.Util
+import scala.tools.partest.BytecodeTest
+import scala.tools.asm
+import scala.collection.JavaConverters._
+
+import scala.tools.asm.Opcodes
+
+object Test extends BytecodeTest {
+
+  def show: Unit = {
+    val t   = transformed(before())
+    val isa = wrapped(t)
+    val isb = wrapped(after())
+    // unreachable code has been removed
+    assert(isa == isb)
+  }
+
+  def wrapped(m: asm.tree.MethodNode) = instructions.fromMethod(m)
+
+  def mkMethodNode = {
+    new asm.tree.MethodNode(
+      Opcodes.ACC_PUBLIC,
+      "m",
+      "()V",
+      null, null
+    )
+  }
+
+  def before(): asm.tree.MethodNode = {
+    val m  = mkMethodNode
+    m.visitInsn(Opcodes.ACONST_NULL)
+    m.visitInsn(Opcodes.ATHROW)
+    m.visitInsn(Opcodes.RETURN)
+
+    m
+  }
+
+  def after(): asm.tree.MethodNode = {
+    val m  = mkMethodNode
+    m.visitInsn(Opcodes.ACONST_NULL)
+    m.visitInsn(Opcodes.ATHROW)
+
+    m
+  }
+
+  def transformed(input: asm.tree.MethodNode): asm.tree.MethodNode = {
+    val tr = new UnreachableCode
+    Util.computeMaxLocalsMaxStack(input)
+    do { tr.transform("C", input) } while (tr.changed)
+
+    input
+  }
+
+}

test/files/jvm/bcode_deadCode_unit_2/Test.scala

@@ -0,0 +1,60 @@
+import scala.tools.nsc.backend.bcode.UnreachableCode
+import scala.tools.nsc.backend.bcode.Util
+import scala.tools.partest.BytecodeTest
+import scala.tools.asm
+import scala.collection.JavaConverters._
+
+import scala.tools.asm.Opcodes
+
+object Test extends BytecodeTest {
+
+  def show: Unit = {
+    val t   = transformed(before())
+    val isa = wrapped(t)
+    val isb = wrapped(after())
+    // unreachable code has been removed
+    assert(isa == isb)
+  }
+
+  def wrapped(m: asm.tree.MethodNode) = instructions.fromMethod(m)
+
+  def mkMethodNode = {
+    new asm.tree.MethodNode(
+      Opcodes.ACC_PUBLIC,
+      "m",
+      "()V",
+      null, null
+    )
+  }
+
+  def before(): asm.tree.MethodNode = {
+    val m  = mkMethodNode
+    val L  = new asm.Label
+    m.visitJumpInsn(Opcodes.GOTO, L)
+    m.visitInsn(Opcodes.ACONST_NULL)
+    m.visitInsn(Opcodes.ATHROW)
+    m.visitLabel(L)
+    m.visitInsn(Opcodes.RETURN)
+
+    m
+  }
+
+  def after(): asm.tree.MethodNode = {
+    val m  = mkMethodNode
+    val L  = new asm.Label
+    m.visitJumpInsn(Opcodes.GOTO, L)
+    m.visitLabel(L)
+    m.visitInsn(Opcodes.RETURN)
+
+    m
+  }
+
+  def transformed(input: asm.tree.MethodNode): asm.tree.MethodNode = {
+    val tr = new UnreachableCode
+    Util.computeMaxLocalsMaxStack(input)
+    do { tr.transform("C", input) } while (tr.changed)
+
+    input
+  }
+
+}