BCodeOpt buidling block: DanglingExcHandlers

This bytecode transformer removes those exception-entries
(corresponding to try-catch-blocks) that are redundant.

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

Author: magarciaEPFL

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

@@ -0,0 +1,92 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2013 LAMP/EPFL
+ * @author  Martin Odersky
+ */
+
+package scala.tools.nsc.backend.bcode;
+
+import java.util.HashSet;
+import java.util.Iterator;
+
+import scala.tools.asm.Opcodes;
+import scala.tools.asm.tree.*;
+
+/**
+ *  Removes redundant exception-entries,
+ *  ie those protecting a range whose only executable instructions are nop.
+ *  Any LineNumberNode or LabelNode in the range are left in place,
+ *  will be removed by follow-up `LabelsCleanup`
+ *
+ *  Just the exception-entry is removed. The bytecode for the exception handler itself
+ *  is left in place, given that it *could* be reachable via normal-control flow
+ *  (although some JIT compilers will bailout compilation if that's the case).
+ *  In case the exception handler code turns out to be unreachable,
+ *  dead-code-elimination will take care of it.
+ *
+ *  The bytecode for a finally-clause that protects an empty block is never removed by this transform.
+ *  In more detail, a finally-clause results in both an EH-version (reachable via exceptional control flow)
+ *  and another non-EH version (reachable via normal-control-flow).
+ *  None of those code blocks is removed by this transform,
+ *  they will be removed (if found to be unreachable) by dead-code elimination.
+ *
+ *  See also Improving the Precision and Correctness of Exception Analysis in Soot,
+ *           http://www.sable.mcgill.ca/publications/techreports/#report2003-3
+ *
+ *  Sidenote: on CLR, the "EH-version" of a finally-clause protecting an empty-block
+ *  can't be removed, because exceptions are handled specially there.
+ *  For example, code running within a finally block is never interrupted by Abort exceptions.
+ *
+ *  @author  Miguel Garcia, http://lamp.epfl.ch/~magarcia/ScalaCompilerCornerReloaded/
+ *  @version 1.0
+ *
+ */
+public class DanglingExcHandlers {
+
+    /** 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 MethodNode mn) {
+
+        changed = false;
+
+        if (mn.tryCatchBlocks == null) { return; }
+
+        Iterator<TryCatchBlockNode> tryIter = mn.tryCatchBlocks.iterator();
+        while (tryIter.hasNext()) {
+            TryCatchBlockNode tcb = tryIter.next();
+
+            assert mn.instructions.contains(tcb.start);
+            assert mn.instructions.contains(tcb.end);
+
+            if (containsJustNopsOrGotos(tcb.start, tcb.end)) {
+                changed = true;
+                tryIter.remove();
+            }
+        }
+
+    }
+
+    /**
+     *  Any LineNumberNode or LabelNode or FrameNode will be skipped.
+     */
+    public boolean containsJustNopsOrGotos(final LabelNode start, final LabelNode end) {
+        assert start != null;
+        assert end   != null;
+
+        AbstractInsnNode current = start;
+        while (current != end) {
+          boolean skip   = (current.getOpcode() == -1);
+          boolean isNOP  = (current.getOpcode() == Opcodes.NOP);
+          boolean isGoto = (current.getOpcode() == Opcodes.GOTO);
+          if (!skip && !isNOP && !isGoto) {
+              return false;
+          }
+          current = current.getNext();
+        }
+
+        return true;
+    }
+
+}
+

test/files/jvm/bcode_danglingExcHandlers_unit_1/Test.scala

@@ -0,0 +1,62 @@
+import scala.tools.nsc.backend.bcode.DanglingExcHandlers
+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 b   = before()
+    assert(b.tryCatchBlocks.size() > 0)
+    val t   = transformed(b)
+    val isa = wrapped(b)
+    val isb = wrapped(t)
+    // redundant exception-entry has been removed
+    assert(t.tryCatchBlocks.size() == 0)
+    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 L1 = new asm.Label
+    val L2 = new asm.Label
+    val L3 = new asm.Label
+    // L1:
+    m.visitLabel(L1)
+    //     nop
+    m.visitInsn(Opcodes.NOP)
+    // L2: --- normal control-flow
+    m.visitLabel(L2)
+    //     return
+    m.visitInsn(Opcodes.RETURN)
+    // L3: --- exceptional control-flow
+    m.visitLabel(L3)
+    //     return
+    m.visitInsn(Opcodes.RETURN)
+
+    m.visitTryCatchBlock(L1, L2, L3, null)
+
+    m
+  }
+
+  def transformed(input: asm.tree.MethodNode): asm.tree.MethodNode = {
+    val tr = new DanglingExcHandlers
+    do { tr.transform(input) } while (tr.changed)
+
+    input
+  }
+
+}