Merge pull request scala#7384 from lrytz/asm7

Upgrade to ASM 7

Author: SethTisue

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

@@ -72,15 +72,11 @@ abstract class PostProcessor extends PerRunInit {
       setInnerClasses(classNode)
       serializeClass(classNode)
     } catch {
-      case e: java.lang.RuntimeException if e.getMessage != null && (e.getMessage contains "too large!") =>
-        backendReporting.error(NoPosition,
-          s"Could not write class ${internalName} because it exceeds JVM code size limits. ${e.getMessage}")
-        null
       case ex: InterruptedException => throw ex
       case ex: Throwable =>
         // TODO fail fast rather than continuing to write the rest of the class files?
         if (frontendAccess.compilerSettings.debug) ex.printStackTrace()
-        backendReporting.error(NoPosition, s"Error while emitting ${internalName}\n${ex.getMessage}")
+        backendReporting.error(NoPosition, s"Error while emitting $internalName\n${ex.getMessage}")
         null
     }
 

src/compiler/scala/tools/nsc/backend/jvm/analysis/NullnessAnalyzer.scala

@@ -149,54 +149,33 @@ final class NullnessInterpreter(knownNonNullInvocation: MethodInsnNode => Boolea
 }
 
 class NullnessFrame(nLocals: Int, nStack: Int) extends AliasingFrame[NullnessValue](nLocals, nStack) {
-  /**
-   * Hack to support branch-dependent values after a null check (if (x == null) ... else ...).
-   * Short pseudo-code of the analyzer:
-   *
-   * analyze()
-   *   while (numInstructionsToProcess > 0) {
-   *     currentFrame = oldFrame.clone().execute(insnNode, interpreter)
-   *     if (insnNode instanceof JumpInsnNode) {
-   *       merge(insnIndex + 1, currentFrame, subroutine)
-   *       merge(jumpInsnIndex, currentFrame, subroutine)
-   *
-   * merge(int insnIndex, Frame frame)
-   *   oldFrame = frames[insnIndex]
-   *   if (oldFrame == null) frames[insnIndex] = newFrame(frame)
-   *   else oldFrame.merge(frame, interpreter)
-   *
-   * The `currentFrame` is a temporary frame with the status after executing the instruction.
-   * It is then either passed to `frame.merge` or to `new Frame` as parameter.
-   *
-   * Both of these methods are overwritten in NullnessFrame to invoke `postBranch()`. On the first
-   * invocation it sets the state of `currentFrame` for the first branch, then for the second branch.
-   * So `currentFrame` can have a different state for each branch.
-   */
-  private var postBranch: () => Unit = null
-
-  override def init(src: Frame[_ <: NullnessValue]): Frame[NullnessValue] = {
-    postBranch = null
-    super.init(src)
-  }
+  private[this] var ifNullAliases: AliasSet = null
 
   // Auxiliary constructor required for implementing `NullnessAnalyzer.newFrame`
   def this(src: Frame[_ <: NullnessValue]) {
     this(src.getLocals, src.getMaxStackSize)
-    val s = src.asInstanceOf[NullnessFrame]
-    if (s.postBranch != null) s.postBranch()
     init(src)
   }
 
-  override def merge(other: Frame[_ <: NullnessValue], interpreter: Interpreter[NullnessValue]): Boolean = {
-    val o = other.asInstanceOf[NullnessFrame]
-    if (o.postBranch != null) o.postBranch()
-    super.merge(other, interpreter)
+  private def setNullness(s: AliasSet, v: NullnessValue) = {
+    val it = s.iterator
+    while (it.hasNext)
+      this.setValue(it.next(), v)
+  }
+
+  override def initJumpTarget(opcode: Int, target: LabelNode): Unit = {
+    // when `target` is defined, we're in the case where the branch condition is true
+    val conditionTrue = target != null
+    if (opcode == Opcodes.IFNULL)
+      setNullness(ifNullAliases, if (conditionTrue) NullValue else NotNullValue)
+    else if (opcode == Opcodes.IFNONNULL)
+      setNullness(ifNullAliases, if (conditionTrue) NotNullValue else NullValue)
   }
 
   override def execute(insn: AbstractInsnNode, interpreter: Interpreter[NullnessValue]): Unit = {
     import Opcodes._
 
-    val ifNullAliases: AliasSet = insn.getOpcode match {
+    ifNullAliases = insn.getOpcode match {
       case IFNULL | IFNONNULL => aliasesOf(this.stackTop)
       case _ => null
     }
@@ -264,24 +243,8 @@ class NullnessFrame(nLocals: Int, nStack: Int) extends AliasingFrame[NullnessVal
 
     super.execute(insn, interpreter)
 
-    def setNullness(s: AliasSet, v: NullnessValue) = {
-      val it = s.iterator
-      while (it.hasNext)
-        this.setValue(it.next(), v)
-    }
-
-    if (ifNullAliases != null) {
-      val v = if (insn.getOpcode == IFNULL) NotNullValue else NullValue
-      postBranch = () => {
-        setNullness(ifNullAliases, v)
-        postBranch = () => {
-          setNullness(ifNullAliases, v.invert)
-          postBranch = null
-        }
-      }
-    }
-
-    if (nullCheckedAliases != null) setNullness(nullCheckedAliases, NotNullValue)
+    if (nullCheckedAliases != null)
+      setNullness(nullCheckedAliases, NotNullValue)
   }
 }
 

src/compiler/scala/tools/nsc/backend/jvm/analysis/ProdConsAnalyzer.scala

@@ -459,16 +459,16 @@ case class ParameterProducer(local: Int)
 case class UninitializedLocalProducer(local: Int)                                       extends InitialProducer
 case class ExceptionProducer[V <: Value](handlerLabel: LabelNode, handlerStackTop: Int) extends InitialProducer
 
-class InitialProducerSourceInterpreter extends SourceInterpreter(scala.tools.asm.Opcodes.ASM7_EXPERIMENTAL) {
+class InitialProducerSourceInterpreter extends SourceInterpreter(scala.tools.asm.Opcodes.ASM7) {
   override def newParameterValue(isInstanceMethod: Boolean, local: Int, tp: Type): SourceValue = {
     new SourceValue(tp.getSize, ParameterProducer(local))
   }
 
-  override def newEmptyNonParameterLocalValue(local: Int): SourceValue = {
+  override def newEmptyValue(local: Int): SourceValue = {
     new SourceValue(1, UninitializedLocalProducer(local))
   }
 
-  override def newExceptionValue(tryCatchBlockNode: TryCatchBlockNode, handlerFrame: Frame[_ <: Value], exceptionType: Type): SourceValue = {
+  override def newExceptionValue(tryCatchBlockNode: TryCatchBlockNode, handlerFrame: Frame[SourceValue], exceptionType: Type): SourceValue = {
     val handlerStackTop = handlerFrame.stackTop + 1 // +1 because this value is about to be pushed onto `handlerFrame`.
     new SourceValue(1, ExceptionProducer(tryCatchBlockNode.handler, handlerStackTop))
   }

src/compiler/scala/tools/nsc/backend/jvm/analysis/TypeFlowAnalyzer.scala

@@ -22,7 +22,7 @@ import scala.tools.nsc.backend.jvm.analysis.TypeFlowInterpreter._
 import scala.tools.nsc.backend.jvm.analysis.BackendUtils.LambdaMetaFactoryCall
 import scala.tools.nsc.backend.jvm.opt.BytecodeUtils._
 
-abstract class TypeFlowInterpreter extends BasicInterpreter(scala.tools.asm.Opcodes.ASM7_EXPERIMENTAL) {
+abstract class TypeFlowInterpreter extends BasicInterpreter(scala.tools.asm.Opcodes.ASM7) {
   override def newParameterValue(isInstanceMethod: Boolean, local: Int, tpe: Type): BasicValue =
     new ParamValue(local, tpe)
 

test/files/run/large_class.check

@@ -1 +1,2 @@
-error: Could not write class BigEnoughToFail because it exceeds JVM code size limits. Class file too large!
+error: Error while emitting BigEnoughToFail
+Class too large: BigEnoughToFail

test/files/run/large_code.check

@@ -1 +1,2 @@
-error: Could not write class BigEnoughToFail because it exceeds JVM code size limits. Method tooLong's code too large!
+error: Error while emitting BigEnoughToFail
+Method too large: BigEnoughToFail.tooLong ()V

versions.properties

@@ -7,5 +7,5 @@ starr.version=2.13.0-M5-6e0cba7
 # Other usages:
 #  - scala-asm: jar content included in scala-compiler
 #  - jline: shaded with JarJar and included in scala-compiler
-scala-asm.version=6.2.0-scala-2
+scala-asm.version=7.0.0-scala-1
 jline.version=2.14.6