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).

Fixes scala/bug#7452

Author: harpocrates

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

@@ -79,9 +79,23 @@ abstract class 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(fun @ 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(fun @ 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)

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

@@ -392,6 +392,7 @@ abstract class 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

test/files/jvm/iinc.check

@@ -0,0 +1,18 @@
+def increment
+  iinc 1
+  iinc 54
+  iinc 127
+  iinc -1
+  iinc -54
+  iinc -128
+end increment
+def wideIncrement
+  iinc 128
+  iinc 8765
+  iinc 32767
+  iinc -129
+  iinc -8765
+  iinc -32768
+end wideIncrement
+def tooBigForIinc
+end tooBigForIinc

test/files/jvm/iinc/Increment_1.scala

@@ -0,0 +1,37 @@
+class Increment {
+
+  // `iinc`
+  def increment(x: Int): Int = {
+    var i = x
+    i += 1
+    i += 54
+    i += 127
+    i -= 1
+    i -= 54
+    i -= 128
+    i
+  }
+
+  // `wide iinc`
+  def wideIncrement(x: Int): Int = {
+    var i = x
+    i += 128
+    i += 8765
+    i += 32767
+    i -= 129
+    i -= 8765
+    i -= 32768
+    i
+  }
+
+  def tooBigForIinc(x: Int): Int = {
+    var i = x
+    i += 32768
+    i += 56789
+    i += 2147483647
+    i -= 32769
+    i -= 56789
+    i -= 2147483647
+    i
+  }
+}

test/files/jvm/iinc/test.scala

@@ -0,0 +1,17 @@
+import scala.tools.partest.BytecodeTest
+
+import scala.tools.asm.tree.IincInsnNode
+
+object Test extends BytecodeTest {
+  def show: Unit = {
+    val classNode = loadClassNode("Increment")
+    for (name <- List("increment", "wideIncrement", "tooBigForIinc")) {
+      println(s"def $name")
+      getMethod(classNode, name).instructions.toArray().collect {
+        case insn: IincInsnNode => println(s"  iinc ${insn.incr}")
+      }
+      println(s"end $name")
+    }
+  }
+}
+