Teach backend to emit iinc instructions

The backend is now able to turn `x += 42` into an `iinc 42`
instruction. The optimization only applies to `+=` and `-=`, provided
the the net increment fits inside a signed 16-bit value (the ASM library
handles choosing `iinc` or `wide iinc` as is appropriate).

Ported from scala/scala#9713

Author: harpocrates

compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala

@@ -88,9 +88,23 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
         case Assign(lhs, rhs) =>
           val s = lhs.symbol
           val Local(tk, _, idx, _) = locals.getOrMakeLocal(s)
-          genLoad(rhs, tk)
-          lineNumber(tree)
-          bc.store(idx, tk)
+
+          rhs match {
+            case Apply(Select(larg: Ident, nme.ADD), Literal(x) :: Nil)
+            if larg.symbol == s && tk.isIntSizedType && x.isShortRange =>
+              lineNumber(tree)
+              bc.iinc(idx, x.intValue)
+
+            case Apply(Select(larg: Ident, nme.SUB), Literal(x) :: Nil)
+            if larg.symbol == s && tk.isIntSizedType && Constant(-x.intValue).isShortRange =>
+              lineNumber(tree)
+              bc.iinc(idx, -x.intValue)
+
+            case _ =>
+              genLoad(rhs, tk)
+              lineNumber(tree)
+              bc.store(idx, tk)
+          }
 
         case _ =>
           genLoad(tree, UNIT)

compiler/src/dotty/tools/backend/jvm/BCodeIdiomatic.scala

@@ -433,6 +433,7 @@ trait BCodeIdiomatic {
 
     final def load( idx: Int, tk: BType): Unit = { emitVarInsn(Opcodes.ILOAD,  idx, tk) } // can-multi-thread
     final def store(idx: Int, tk: BType): Unit = { emitVarInsn(Opcodes.ISTORE, idx, tk) } // can-multi-thread
+    final def iinc( idx: Int, increment: Int): Unit = jmethod.visitIincInsn(idx, increment) // can-multi-thread
 
     final def aload( tk: BType): Unit = { emitTypeBased(JCodeMethodN.aloadOpcodes,  tk) } // can-multi-thread
     final def astore(tk: BType): Unit = { emitTypeBased(JCodeMethodN.astoreOpcodes, tk) } // can-multi-thread

compiler/test/dotty/tools/backend/jvm/IincTest.scala

@@ -0,0 +1,71 @@
+package dotty.tools.backend.jvm
+
+import org.junit.Test
+import org.junit.Assert._
+
+import scala.tools.asm.Opcodes._
+
+class IincTest extends DottyBytecodeTest {
+  import ASMConverters._
+
+  @Test def increment = test(
+    """{
+      |  var i = x
+      |  i += 1
+      |  i += 54
+      |  i += 127
+      |  i -= 1
+      |  i -= 54
+      |  i -= 128
+      |  i
+      |}""".stripMargin,
+    List(1, 54, 127, -1, -54, -128)
+  )
+
+  @Test def wideIncrement = test(
+    """{
+      |  var i = x
+      |  i += 128
+      |  i += 8765
+      |  i += 32767
+      |  i -= 129
+      |  i -= 8765
+      |  i -= 32768
+      |  i
+      |}""".stripMargin,
+    List(128, 8765, 32767, -129, -8765, -32768)
+  )
+
+  @Test def tooBigForIinc = test(
+    """{
+      |  var i = x
+      |  i += 32768
+      |  i += 56789
+      |  i += 2147483647
+      |  i -= 32769
+      |  i -= 56789
+      |  i -= 2147483647
+      |  i
+      |}""".stripMargin,
+    Nil
+  )
+
+  private def test(code: String, expectedIincs: List[Int])= {
+    val source =
+      s"""class Increment {
+         | def test(x: Int): Int = $code
+         |}
+       """.stripMargin
+
+    checkBCode(source) { dir =>
+      val clsIn   = dir.lookupName("Increment.class", directory = false).input
+      val clsNode = loadClassNode(clsIn)
+      val meth   = getMethod(clsNode, "test")
+
+      val foundIincs = instructionsFromMethod(meth).collect { case iinc: Incr => iinc.incr }
+
+      assertEquals(expectedIincs, foundIincs)
+    }
+  }
+
+}