From 093be1add315bd5b76057e943bdba1a4cc198a0d Mon Sep 17 00:00:00 2001
From: Lukas Rytz <lukas.rytz@gmail.com>
Date: Mon, 30 Mar 2015 12:09:30 +0200
Subject: Make class Invalid a ControlThrowable

Invalid is used for control flow in RightBiasedEither.orThrow.
---
 src/compiler/scala/tools/nsc/backend/jvm/BackendReporting.scala | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'src/compiler')

diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BackendReporting.scala b/src/compiler/scala/tools/nsc/backend/jvm/BackendReporting.scala
index a06fb4bab8..be67da7137 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BackendReporting.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BackendReporting.scala
@@ -4,6 +4,7 @@ package backend.jvm
 import scala.tools.asm.tree.{AbstractInsnNode, MethodNode}
 import scala.tools.nsc.backend.jvm.BTypes.InternalName
 import scala.reflect.internal.util.Position
+import scala.util.control.ControlThrowable
 
 /**
  * Interface for emitting inline warnings. The interface is required because the implementation
@@ -73,7 +74,7 @@ object BackendReporting {
     }
   }
 
-  case class Invalid[A](e: A) extends Exception
+  case class Invalid[A](e: A) extends ControlThrowable
 
   /**
    * See documentation of orThrow above.
-- 
cgit v1.2.3


From 6cf17ccd0101514a603a8c191438bdc2764838f9 Mon Sep 17 00:00:00 2001
From: Lukas Rytz <lukas.rytz@gmail.com>
Date: Mon, 30 Mar 2015 12:11:37 +0200
Subject: Command-line flag to control inlining heuristics

Introduces a stress-test mode "everything" in which the inliner tries
to inline every calliste that can be statically resolved.
---
 src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala            | 2 ++
 src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala | 2 ++
 src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala       | 3 ++-
 src/compiler/scala/tools/nsc/settings/ScalaSettings.scala        | 9 ++++++++-
 4 files changed, 14 insertions(+), 2 deletions(-)

(limited to 'src/compiler')

diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
index d8a17e975e..74990fad02 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
@@ -57,6 +57,8 @@ abstract class BTypes {
   // Settings that define what kind of optimizer warnings are emitted.
   def warnSettings: WarnSettings
 
+  def inliningHeuristics: String
+
   /**
    * A map from internal names to ClassBTypes. Every ClassBType is added to this map on its
    * construction.
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
index eeb6ed24a2..ad434889cf 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
@@ -63,6 +63,8 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
       settings.YoptWarnings.contains(c.noInlineMissingScalaInlineInfoAttr.name))
   }
 
+  def inliningHeuristics: String = settings.YoptInlineHeuristics.value
+
   // helpers that need access to global.
   // TODO @lry create a separate component, they don't belong to BTypesFromSymbols
 
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
index e14e57d3ab..fbbb6bb5e0 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
@@ -106,7 +106,8 @@ class Inliner[BT <: BTypes](val btypes: BT) {
    */
   def doInlineCallsite(callsite: Callsite): Boolean = callsite match {
     case Callsite(_, _, _, Right(Callee(callee, calleeDeclClass, safeToInline, _, annotatedInline, _, warning)), _, _, pos) =>
-      annotatedInline && safeToInline
+      if (inliningHeuristics == "everything") safeToInline
+      else annotatedInline && safeToInline
 
     case _ => false
   }
diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
index d273995e6e..ee683418d9 100644
--- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
@@ -256,6 +256,13 @@ trait ScalaSettings extends AbsScalaSettings
   def YoptInlineGlobal            = Yopt.contains(YoptChoices.inlineGlobal)
   def YoptInlinerEnabled          = YoptInlineProject || YoptInlineGlobal
 
+  val YoptInlineHeuristics = ChoiceSetting(
+    name = "-Yopt-inline-heuristics",
+    helpArg = "strategy",
+    descr = "Set the heuristics for inlining decisions.",
+    choices = List("at-inline-annotated", "everything"),
+    default = "at-inline-annotated")
+
   object YoptWarningsChoices extends MultiChoiceEnumeration {
     val none                               = Choice("none"                       , "No optimizer warnings.")
     val atInlineFailedSummary              = Choice("at-inline-failed-summary"   , "One-line summary if there were @inline method calls that could not be inlined.")
@@ -267,7 +274,7 @@ trait ScalaSettings extends AbsScalaSettings
 
   val YoptWarnings = MultiChoiceSetting(
     name = "-Yopt-warnings",
-    helpArg = "warnings",
+    helpArg = "warning",
     descr = "Enable optimizer warnings",
     domain = YoptWarningsChoices,
     default = Some(List(YoptWarningsChoices.atInlineFailed.name))) withPostSetHook (self => {
-- 
cgit v1.2.3


From fa110edd473ac5bbdb66fbd5a51fa2685c0dcf21 Mon Sep 17 00:00:00 2001
From: Lukas Rytz <lukas.rytz@gmail.com>
Date: Mon, 30 Mar 2015 14:07:23 +0200
Subject: Eliminate unreachable code before inlining a method

Running an ASM analyzer returns null frames for unreachable
instructions in the analyzed method. The inliner (and other components
of the optimizer) require unreachable code to be eliminated to avoid
null frames.

Before this change, unreachable code was eliminated before building
the call graph, but not again before inlining: the inliner assumed
that methods in the call graph have no unreachable code.

This invariant can break when inlining a method. Example:

  def f = throw e
  def g = f; println()

When building the call graph, both f and g contain no unreachable
code. After inlining f, the println() call becomes unreachable. This
breaks the inliner's assumption if it tries to inline a call to g.

This change intruduces a cache to remember methods that have no
unreachable code. This allows invoking DCE every time no dead code is
required, and bail out fast. This also simplifies following the
control flow in the optimizer (call DCE whenever no dead code is
required).
---
 .../scala/tools/nsc/backend/jvm/BTypes.scala       | 16 ++++++-
 .../tools/nsc/backend/jvm/BTypesFromSymbols.scala  |  4 +-
 .../scala/tools/nsc/backend/jvm/GenBCode.scala     |  8 ++--
 .../tools/nsc/backend/jvm/opt/CallGraph.scala      |  3 +-
 .../scala/tools/nsc/backend/jvm/opt/Inliner.scala  | 41 +++++++++++++----
 .../scala/tools/nsc/backend/jvm/opt/LocalOpt.scala | 53 +++++++++++-----------
 .../scala/tools/nsc/backend/jvm/CodeGenTools.scala |  2 +-
 .../tools/nsc/backend/jvm/opt/InlinerTest.scala    | 14 ++++++
 8 files changed, 96 insertions(+), 45 deletions(-)

(limited to 'src/compiler')

diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
index 74990fad02..57471874e2 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
@@ -11,7 +11,7 @@ import scala.collection.concurrent.TrieMap
 import scala.reflect.internal.util.Position
 import scala.tools.asm
 import asm.Opcodes
-import scala.tools.asm.tree.{MethodInsnNode, InnerClassNode, ClassNode}
+import scala.tools.asm.tree.{MethodNode, MethodInsnNode, InnerClassNode, ClassNode}
 import scala.tools.nsc.backend.jvm.BTypes.{InlineInfo, MethodInlineInfo}
 import scala.tools.nsc.backend.jvm.BackendReporting._
 import scala.tools.nsc.backend.jvm.opt._
@@ -39,6 +39,8 @@ abstract class BTypes {
    */
   val byteCodeRepository: ByteCodeRepository
 
+  val localOpt: LocalOpt
+
   val inliner: Inliner[this.type]
 
   val callGraph: CallGraph[this.type]
@@ -84,6 +86,18 @@ abstract class BTypes {
    */
   val javaDefinedClasses: collection.mutable.Set[InternalName] = recordPerRunCache(collection.mutable.Set.empty)
 
+  /**
+   * Cache, contains methods whose unreachable instructions are eliminated.
+   *
+   * The ASM Analyzer class does not compute any frame information for unreachable instructions.
+   * Transformations that use an analyzer (including inlining) therefore require unreachable code
+   * to be eliminated.
+   *
+   * This cache allows running dead code elimination whenever an analyzer is used. If the method
+   * is already optimized, DCE can return early.
+   */
+  val unreachableCodeEliminated: collection.mutable.Set[MethodNode] = recordPerRunCache(collection.mutable.Set.empty)
+
   /**
    * Obtain the BType for a type descriptor or internal name. For class descriptors, the ClassBType
    * is constructed by parsing the corresponding classfile.
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
index ad434889cf..41ce35888a 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
@@ -7,7 +7,7 @@ package scala.tools.nsc
 package backend.jvm
 
 import scala.tools.asm
-import scala.tools.nsc.backend.jvm.opt.{CallGraph, Inliner, ByteCodeRepository}
+import scala.tools.nsc.backend.jvm.opt.{LocalOpt, CallGraph, Inliner, ByteCodeRepository}
 import scala.tools.nsc.backend.jvm.BTypes.{InlineInfo, MethodInlineInfo, InternalName}
 import BackendReporting._
 
@@ -37,6 +37,8 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
 
   val byteCodeRepository = new ByteCodeRepository(global.classPath, javaDefinedClasses, recordPerRunCache(collection.concurrent.TrieMap.empty))
 
+  val localOpt = new LocalOpt(settings, unreachableCodeEliminated)
+
   val inliner: Inliner[this.type] = new Inliner(this)
 
   val callGraph: CallGraph[this.type] = new CallGraph(this)
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala
index be1595dc29..4bfd70bf1e 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala
@@ -215,17 +215,15 @@ abstract class GenBCode extends BCodeSyncAndTry {
      *          - converting the plain ClassNode to byte array and placing it on queue-3
      */
     class Worker2 {
-      lazy val localOpt = new LocalOpt(settings)
+      // This instance is removed in a future commit that refactors LocalOpt
+      lazy val localOpt = new LocalOpt(settings, collection.mutable.Set())
 
       def runGlobalOptimizations(): Unit = {
         import scala.collection.convert.decorateAsScala._
         q2.asScala foreach {
           case Item2(_, _, plain, _, _) =>
             // skip mirror / bean: wd don't inline into tem, and they are not used in the plain class
-            if (plain != null) {
-              localOpt.minimalRemoveUnreachableCode(plain)
-              callGraph.addClass(plain)
-            }
+            if (plain != null) callGraph.addClass(plain)
         }
         bTypes.inliner.runInliner()
       }
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/CallGraph.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/CallGraph.scala
index 47d32c94cb..a5a9f5e054 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/CallGraph.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/CallGraph.scala
@@ -50,7 +50,7 @@ class CallGraph[BT <: BTypes](val btypes: BT) {
             // (1) A non-final method can be safe to inline if the receiver type is a final subclass. Example:
             //   class A { @inline def f = 1 }; object B extends A; B.f  // can be inlined
             //
-            // TODO: type analysis can render more calls statically resolved. Example˜∫
+            // TODO: type analysis can render more calls statically resolved. Example:
             //   new A.f  // can be inlined, the receiver type is known to be exactly A.
             val isStaticallyResolved: Boolean = {
               methodInlineInfo.effectivelyFinal ||
@@ -92,6 +92,7 @@ class CallGraph[BT <: BTypes](val btypes: BT) {
 
     // TODO: for now we run a basic analyzer to get the stack height at the call site.
     // once we run a more elaborate analyzer (types, nullness), we can get the stack height out of there.
+    localOpt.minimalRemoveUnreachableCode(methodNode, definingClass.internalName)
     val analyzer = new AsmAnalyzer(methodNode, definingClass.internalName)
 
     methodNode.instructions.iterator.asScala.collect({
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
index fbbb6bb5e0..538b02cdbb 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
@@ -24,21 +24,39 @@ class Inliner[BT <: BTypes](val btypes: BT) {
   import btypes._
   import callGraph._
 
+  def eliminateUnreachableCodeAndUpdateCallGraph(methodNode: MethodNode, definingClass: InternalName): Unit = {
+    localOpt.minimalRemoveUnreachableCode(methodNode, definingClass) foreach {
+      case invocation: MethodInsnNode => callGraph.callsites.remove(invocation)
+      case _ =>
+    }
+  }
+
   def runInliner(): Unit = {
     rewriteFinalTraitMethodInvocations()
 
     for (request <- collectAndOrderInlineRequests) {
       val Right(callee) = request.callee // collectAndOrderInlineRequests returns callsites with a known callee
 
-      val r = inline(request.callsiteInstruction, request.callsiteStackHeight, request.callsiteMethod, request.callsiteClass,
-        callee.callee, callee.calleeDeclarationClass,
-        receiverKnownNotNull = false, keepLineNumbers = false)
-
-      for (warning <- r) {
-        if ((callee.annotatedInline && btypes.warnSettings.atInlineFailed) || warning.emitWarning(warnSettings)) {
-          val annotWarn = if (callee.annotatedInline) " is annotated @inline but" else ""
-          val msg = s"${BackendReporting.methodSignature(callee.calleeDeclarationClass.internalName, callee.callee)}$annotWarn could not be inlined:\n$warning"
-          backendReporting.inlinerWarning(request.callsitePosition, msg)
+      // Inlining a method can create unreachable code. Example:
+      //   def f = throw e
+      //   def g = f; println() // println is unreachable after inlining f
+      // If we have an inline request for a call to g, and f has been already inlined into g, we
+      // need to run DCE before inlining g.
+      eliminateUnreachableCodeAndUpdateCallGraph(callee.callee, callee.calleeDeclarationClass.internalName)
+
+      // DCE above removes unreachable callsites from the call graph. If the inlining request denotes
+      // such an eliminated callsite, do nothing.
+      if (callGraph.callsites contains request.callsiteInstruction) {
+        val r = inline(request.callsiteInstruction, request.callsiteStackHeight, request.callsiteMethod, request.callsiteClass,
+          callee.callee, callee.calleeDeclarationClass,
+          receiverKnownNotNull = false, keepLineNumbers = false)
+
+        for (warning <- r) {
+          if ((callee.annotatedInline && btypes.warnSettings.atInlineFailed) || warning.emitWarning(warnSettings)) {
+            val annotWarn = if (callee.annotatedInline) " is annotated @inline but" else ""
+            val msg = s"${BackendReporting.methodSignature(callee.calleeDeclarationClass.internalName, callee.callee)}$annotWarn could not be inlined:\n$warning"
+            backendReporting.inlinerWarning(request.callsitePosition, msg)
+          }
         }
       }
     }
@@ -168,6 +186,8 @@ class Inliner[BT <: BTypes](val btypes: BT) {
         // VerifyError. We run a `SourceInterpreter` to find all producer instructions of the
         // receiver value and add a cast to the self type after each.
         if (!selfTypeOk) {
+          // there's no need to run eliminateUnreachableCode here. building the call graph does that
+          // already, no code can become unreachable in the meantime.
           val analyzer = new AsmAnalyzer(callsite.callsiteMethod, callsite.callsiteClass.internalName, new SourceInterpreter)
           val receiverValue = analyzer.frameAt(callsite.callsiteInstruction).peekDown(traitMethodArgumentTypes.length)
           for (i <- receiverValue.insns.asScala) {
@@ -434,6 +454,9 @@ class Inliner[BT <: BTypes](val btypes: BT) {
       // Remove the elided invocation from the call graph
       callGraph.callsites.remove(callsiteInstruction)
 
+      // Inlining a method body can render some code unreachable, see example above (in runInliner).
+      unreachableCodeEliminated -= callsiteMethod
+
       callsiteMethod.maxLocals += returnType.getSize + callee.maxLocals
       callsiteMethod.maxStack = math.max(callsiteMethod.maxStack, callee.maxStack + callsiteStackHeight)
 
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala
index f6cfc5598b..fb5cfeb167 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala
@@ -47,44 +47,37 @@ import scala.tools.nsc.settings.ScalaSettings
  * stale labels
  *   - eliminate labels that are not referenced, merge sequences of label definitions.
  */
-class LocalOpt(settings: ScalaSettings) {
-  /**
-   * Remove unreachable code from all methods of `classNode`. See of its overload.
-   *
-   * @param classNode The class to optimize
-   * @return          `true` if unreachable code was removed from any method
-   */
-  def minimalRemoveUnreachableCode(classNode: ClassNode): Boolean = {
-    classNode.methods.asScala.foldLeft(false) {
-      case (changed, method) => minimalRemoveUnreachableCode(method, classNode.name) || changed
-    }
-  }
-
+class LocalOpt(settings: ScalaSettings, unreachableCodeEliminated: collection.mutable.Set[MethodNode]) {
   /**
    * Remove unreachable code from a method.
    *
    * This implementation only removes instructions that are unreachable for an ASM analyzer /
    * interpreter. This ensures that future analyses will not produce `null` frames. The inliner
    * and call graph builder depend on this property.
+   *
+   * @return A set containing the eliminated instructions
    */
-  def minimalRemoveUnreachableCode(method: MethodNode, ownerClassName: InternalName): Boolean = {
-    if (method.instructions.size == 0) return false // fast path for abstract methods
+  def minimalRemoveUnreachableCode(method: MethodNode, ownerClassName: InternalName): Set[AbstractInsnNode] = {
+    if (method.instructions.size == 0) return Set.empty     // fast path for abstract methods
+    if (unreachableCodeEliminated(method)) return Set.empty // we know there is no unreachable code
 
     // For correctness, after removing unreachable code, we have to eliminate empty exception
     // handlers, see scaladoc of def methodOptimizations. Removing an live handler may render more
     // code unreachable and therefore requires running another round.
-    def removalRound(): Boolean = {
-      val (codeRemoved, liveLabels) = removeUnreachableCodeImpl(method, ownerClassName)
-      if (codeRemoved) {
+    def removalRound(): Set[AbstractInsnNode] = {
+      val (removedInstructions, liveLabels) = removeUnreachableCodeImpl(method, ownerClassName)
+      val removedRecursively = if (removedInstructions.nonEmpty) {
         val liveHandlerRemoved = removeEmptyExceptionHandlers(method).exists(h => liveLabels(h.start))
         if (liveHandlerRemoved) removalRound()
-      }
-      codeRemoved
+        else Set.empty
+      } else Set.empty
+      removedInstructions ++ removedRecursively
     }
 
-    val codeRemoved = removalRound()
-    if (codeRemoved) removeUnusedLocalVariableNodes(method)()
-    codeRemoved
+    val removedInstructions = removalRound()
+    if (removedInstructions.nonEmpty) removeUnusedLocalVariableNodes(method)()
+    unreachableCodeEliminated += method
+    removedInstructions
   }
 
   /**
@@ -145,9 +138,9 @@ class LocalOpt(settings: ScalaSettings) {
     def removalRound(): Boolean = {
       // unreachable-code, empty-handlers and simplify-jumps run until reaching a fixpoint (see doc on class LocalOpt)
       val (codeRemoved, handlersRemoved, liveHandlerRemoved) = if (settings.YoptUnreachableCode) {
-        val (codeRemoved, liveLabels) = removeUnreachableCodeImpl(method, ownerClassName)
+        val (removedInstructions, liveLabels) = removeUnreachableCodeImpl(method, ownerClassName)
         val removedHandlers = removeEmptyExceptionHandlers(method)
-        (codeRemoved, removedHandlers.nonEmpty, removedHandlers.exists(h => liveLabels(h.start)))
+        (removedInstructions.nonEmpty, removedHandlers.nonEmpty, removedHandlers.exists(h => liveLabels(h.start)))
       } else {
         (false, false, false)
       }
@@ -179,6 +172,8 @@ class LocalOpt(settings: ScalaSettings) {
     assert(nullOrEmpty(method.visibleLocalVariableAnnotations), method.visibleLocalVariableAnnotations)
     assert(nullOrEmpty(method.invisibleLocalVariableAnnotations), method.invisibleLocalVariableAnnotations)
 
+    unreachableCodeEliminated += method
+
     codeHandlersOrJumpsChanged || localsRemoved || lineNumbersRemoved || labelsRemoved
   }
 
@@ -186,8 +181,10 @@ class LocalOpt(settings: ScalaSettings) {
    * Removes unreachable basic blocks.
    *
    * TODO: rewrite, don't use computeMaxLocalsMaxStack (runs a ClassWriter) / Analyzer. Too slow.
+   *
+   * @return A set containing eliminated instructions, and a set containing all live label nodes.
    */
-  def removeUnreachableCodeImpl(method: MethodNode, ownerClassName: InternalName): (Boolean, Set[LabelNode]) = {
+  def removeUnreachableCodeImpl(method: MethodNode, ownerClassName: InternalName): (Set[AbstractInsnNode], Set[LabelNode]) = {
     // The data flow analysis requires the maxLocals / maxStack fields of the method to be computed.
     computeMaxLocalsMaxStack(method)
     val a = new Analyzer(new BasicInterpreter)
@@ -197,6 +194,7 @@ class LocalOpt(settings: ScalaSettings) {
     val initialSize = method.instructions.size
     var i = 0
     var liveLabels = Set.empty[LabelNode]
+    var removedInstructions = Set.empty[AbstractInsnNode]
     val itr = method.instructions.iterator()
     while (itr.hasNext) {
       itr.next() match {
@@ -209,11 +207,12 @@ class LocalOpt(settings: ScalaSettings) {
             // Instruction iterators allow removing during iteration.
             // Removing is O(1): instructions are doubly linked list elements.
             itr.remove()
+            removedInstructions += ins
           }
       }
       i += 1
     }
-    (method.instructions.size != initialSize, liveLabels)
+    (removedInstructions, liveLabels)
   }
 
   /**
diff --git a/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala b/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala
index 5d5215d887..3ba3caa5e3 100644
--- a/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala
+++ b/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala
@@ -160,7 +160,7 @@ object CodeGenTools {
   val localOpt = {
     val settings = new MutableSettings(msg => throw new IllegalArgumentException(msg))
     settings.processArguments(List("-Yopt:l:method"), processAll = true)
-    new LocalOpt(settings)
+    new LocalOpt(settings, collection.mutable.Set())
   }
 
   import scala.language.implicitConversions
diff --git a/test/junit/scala/tools/nsc/backend/jvm/opt/InlinerTest.scala b/test/junit/scala/tools/nsc/backend/jvm/opt/InlinerTest.scala
index 39fb28570e..9d23d92c2a 100644
--- a/test/junit/scala/tools/nsc/backend/jvm/opt/InlinerTest.scala
+++ b/test/junit/scala/tools/nsc/backend/jvm/opt/InlinerTest.scala
@@ -950,4 +950,18 @@ class InlinerTest extends ClearAfterClass {
     assertInvoke(getSingleMethod(t, "t3"), "B", "<init>")
     assertInvoke(getSingleMethod(t, "t4"), "B", "<init>")
   }
+
+  @Test
+  def inlineMayRenderCodeDead(): Unit = {
+    val code =
+      """class C {
+        |  @inline final def f: String = throw new Error("")
+        |  @inline final def g: String = "a" + f + "b"       // after inlining f, need to run DCE, because the rest of g becomes dead.
+        |  def t = g                                         // the inliner requires no dead code when inlining g (uses an Analyzer).
+        |}
+      """.stripMargin
+
+    val List(c) = compile(code)
+    assertInvoke(getSingleMethod(c, "t"), "java/lang/Error", "<init>")
+  }
 }
-- 
cgit v1.2.3


From eb43d62b4e0665b6b509a04d4ec2edae53c9256b Mon Sep 17 00:00:00 2001
From: Lukas Rytz <lukas.rytz@gmail.com>
Date: Mon, 30 Mar 2015 14:09:17 +0200
Subject: Don't try to inline native methods

Because you can't, really.
---
 .../scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala       |  2 ++
 src/compiler/scala/tools/nsc/backend/jvm/opt/CallGraph.scala  |  9 +++++++--
 test/junit/scala/tools/nsc/backend/jvm/opt/InlinerTest.scala  | 11 +++++++++++
 3 files changed, 20 insertions(+), 2 deletions(-)

(limited to 'src/compiler')

diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala
index 14e8cccc60..a295bc49b1 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala
@@ -83,6 +83,8 @@ object BytecodeUtils {
 
   def isSynchronizedMethod(methodNode: MethodNode): Boolean = (methodNode.access & Opcodes.ACC_SYNCHRONIZED) != 0
 
+  def isNativeMethod(methodNode: MethodNode): Boolean = (methodNode.access & Opcodes.ACC_NATIVE) != 0
+
   def isFinalClass(classNode: ClassNode): Boolean = (classNode.access & Opcodes.ACC_FINAL) != 0
 
   def isFinalMethod(methodNode: MethodNode): Boolean = (methodNode.access & (Opcodes.ACC_FINAL | Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC)) != 0
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/CallGraph.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/CallGraph.scala
index a5a9f5e054..cdd3f463de 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/CallGraph.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/CallGraph.scala
@@ -68,8 +68,13 @@ class CallGraph[BT <: BTypes](val btypes: BT) {
             // (2) Final trait methods can be rewritten from the interface to the static implementation
             //     method to enable inlining.
             CallsiteInfo(
-              safeToInline      = canInlineFromSource && isStaticallyResolved && !isAbstract, // (1)
-              safeToRewrite     = canInlineFromSource && isRewritableTraitCall,               // (2)
+              safeToInline      =
+                canInlineFromSource &&
+                isStaticallyResolved &&  // (1)
+                !isAbstract &&
+                !BytecodeUtils.isConstructor(calleeMethodNode) &&
+                !BytecodeUtils.isNativeMethod(calleeMethodNode),
+              safeToRewrite     = canInlineFromSource && isRewritableTraitCall, // (2)
               annotatedInline   = methodInlineInfo.annotatedInline,
               annotatedNoInline = methodInlineInfo.annotatedNoInline,
               warning           = warning)
diff --git a/test/junit/scala/tools/nsc/backend/jvm/opt/InlinerTest.scala b/test/junit/scala/tools/nsc/backend/jvm/opt/InlinerTest.scala
index 9d23d92c2a..d113598ce5 100644
--- a/test/junit/scala/tools/nsc/backend/jvm/opt/InlinerTest.scala
+++ b/test/junit/scala/tools/nsc/backend/jvm/opt/InlinerTest.scala
@@ -951,6 +951,17 @@ class InlinerTest extends ClearAfterClass {
     assertInvoke(getSingleMethod(t, "t4"), "B", "<init>")
   }
 
+  @Test
+  def dontInlineNative(): Unit = {
+    val code =
+      """class C {
+        |  def t = System.arraycopy(null, 0, null, 0, 0)
+        |}
+      """.stripMargin
+    val List(c) = compileClasses(newCompiler(extraArgs = InlinerTest.args + " -Yopt-inline-heuristics:everything"))(code)
+    assertInvoke(getSingleMethod(c, "t"), "java/lang/System", "arraycopy")
+  }
+
   @Test
   def inlineMayRenderCodeDead(): Unit = {
     val code =
-- 
cgit v1.2.3


From 638ed9108f10bcbebb69f2fefe05c7423c8bdfd7 Mon Sep 17 00:00:00 2001
From: Lukas Rytz <lukas.rytz@gmail.com>
Date: Mon, 30 Mar 2015 16:19:25 +0200
Subject: Clean up the way compiler settings are accessed in the backend.

Many backend components don't have access to the compiler instance
holding the settings.

Before this change, individual settings required in these parts of the
backend were made available as members of trait BTypes, implemented
in the subclass BTypesFromSymbols (which has access to global).

This change exposes a single value of type ScalaSettings in the super
trait BTypes, which gives access to all compiler settings.
---
 .../scala/tools/nsc/backend/jvm/BTypes.scala       | 16 +++-------
 .../tools/nsc/backend/jvm/BTypesFromSymbols.scala  | 23 +++-----------
 .../tools/nsc/backend/jvm/BackendReporting.scala   | 37 +++++++++++-----------
 .../scala/tools/nsc/backend/jvm/GenBCode.scala     |  4 ---
 .../tools/nsc/backend/jvm/opt/CallGraph.scala      |  2 +-
 .../scala/tools/nsc/backend/jvm/opt/Inliner.scala  | 12 +++----
 .../scala/tools/nsc/backend/jvm/opt/LocalOpt.scala | 23 ++++++++------
 .../scala/tools/nsc/settings/ScalaSettings.scala   |  9 ++++++
 .../scala/tools/nsc/backend/jvm/CodeGenTools.scala |  7 ----
 .../jvm/opt/EmptyExceptionHandlersTest.scala       |  4 +--
 .../jvm/opt/EmptyLabelsAndLineNumbersTest.scala    |  6 ++--
 .../tools/nsc/backend/jvm/opt/InlinerTest.scala    |  2 +-
 .../nsc/backend/jvm/opt/SimplifyJumpsTest.scala    | 24 +++++++-------
 .../nsc/backend/jvm/opt/UnreachableCodeTest.scala  |  2 +-
 14 files changed, 77 insertions(+), 94 deletions(-)

(limited to 'src/compiler')

diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
index 57471874e2..d690542f0e 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
@@ -16,6 +16,7 @@ import scala.tools.nsc.backend.jvm.BTypes.{InlineInfo, MethodInlineInfo}
 import scala.tools.nsc.backend.jvm.BackendReporting._
 import scala.tools.nsc.backend.jvm.opt._
 import scala.collection.convert.decorateAsScala._
+import scala.tools.nsc.settings.ScalaSettings
 
 /**
  * The BTypes component defines The BType class hierarchy. A BType stores all type information
@@ -39,7 +40,7 @@ abstract class BTypes {
    */
   val byteCodeRepository: ByteCodeRepository
 
-  val localOpt: LocalOpt
+  val localOpt: LocalOpt[this.type]
 
   val inliner: Inliner[this.type]
 
@@ -50,16 +51,9 @@ abstract class BTypes {
   // Allows to define per-run caches here and in the CallGraph component, which don't have a global
   def recordPerRunCache[T <: collection.generic.Clearable](cache: T): T
 
-  // When building the call graph, we need to know if global inlining is allowed (the component doesn't have a global)
-  def inlineGlobalEnabled: Boolean
+  // Allows access to the compiler settings for backend components that don't have a global in scope
+  def compilerSettings: ScalaSettings
 
-  // When the inliner is not enabled, there's no point in adding InlineInfos to all ClassBTypes
-  def inlinerEnabled: Boolean
-
-  // Settings that define what kind of optimizer warnings are emitted.
-  def warnSettings: WarnSettings
-
-  def inliningHeuristics: String
 
   /**
    * A map from internal names to ClassBTypes. Every ClassBType is added to this map on its
@@ -245,7 +239,7 @@ abstract class BTypes {
     // The InlineInfo is built from the classfile (not from the symbol) for all classes that are NOT
     // being compiled. For those classes, the info is only needed if the inliner is enabled, othewise
     // we can save the memory.
-    if (!inlinerEnabled) BTypes.EmptyInlineInfo
+    if (!compilerSettings.YoptInlinerEnabled) BTypes.EmptyInlineInfo
     else fromClassfileAttribute getOrElse fromClassfileWithoutAttribute
   }
 
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
index 41ce35888a..1b9fd5e298 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
@@ -10,6 +10,7 @@ import scala.tools.asm
 import scala.tools.nsc.backend.jvm.opt.{LocalOpt, CallGraph, Inliner, ByteCodeRepository}
 import scala.tools.nsc.backend.jvm.BTypes.{InlineInfo, MethodInlineInfo, InternalName}
 import BackendReporting._
+import scala.tools.nsc.settings.ScalaSettings
 
 /**
  * This class mainly contains the method classBTypeFromSymbol, which extracts the necessary
@@ -37,7 +38,7 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
 
   val byteCodeRepository = new ByteCodeRepository(global.classPath, javaDefinedClasses, recordPerRunCache(collection.concurrent.TrieMap.empty))
 
-  val localOpt = new LocalOpt(settings, unreachableCodeEliminated)
+  val localOpt: LocalOpt[this.type] = new LocalOpt(this)
 
   val inliner: Inliner[this.type] = new Inliner(this)
 
@@ -51,21 +52,7 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
 
   def recordPerRunCache[T <: collection.generic.Clearable](cache: T): T = perRunCaches.recordCache(cache)
 
-  def inlineGlobalEnabled: Boolean = settings.YoptInlineGlobal
-
-  def inlinerEnabled: Boolean      = settings.YoptInlinerEnabled
-
-  def warnSettings: WarnSettings   = {
-    val c = settings.YoptWarningsChoices
-    // cannot extract settings.YoptWarnings into a local val due to some dependent typing issue.
-    WarnSettings(
-      !settings.YoptWarnings.isSetByUser || settings.YoptWarnings.contains(c.atInlineFailedSummary.name) || settings.YoptWarnings.contains(c.atInlineFailed.name),
-      settings.YoptWarnings.contains(c.noInlineMixed.name),
-      settings.YoptWarnings.contains(c.noInlineMissingBytecode.name),
-      settings.YoptWarnings.contains(c.noInlineMissingScalaInlineInfoAttr.name))
-  }
-
-  def inliningHeuristics: String = settings.YoptInlineHeuristics.value
+  def compilerSettings: ScalaSettings = settings
 
   // helpers that need access to global.
   // TODO @lry create a separate component, they don't belong to BTypesFromSymbols
@@ -422,8 +409,8 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
     // phase travel required, see implementation of `compiles`. for nested classes, it checks if the
     // enclosingTopLevelClass is being compiled. after flatten, all classes are considered top-level,
     // so `compiles` would return `false`.
-    if (exitingPickler(currentRun.compiles(classSym))) buildFromSymbol // InlineInfo required for classes being compiled, we have to create the classfile attribute
-    else if (!inlinerEnabled) BTypes.EmptyInlineInfo                   // For other classes, we need the InlineInfo only inf the inliner is enabled.
+    if (exitingPickler(currentRun.compiles(classSym))) buildFromSymbol    // InlineInfo required for classes being compiled, we have to create the classfile attribute
+    else if (!compilerSettings.YoptInlinerEnabled) BTypes.EmptyInlineInfo // For other classes, we need the InlineInfo only inf the inliner is enabled.
     else {
       // For classes not being compiled, the InlineInfo is read from the classfile attribute. This
       // fixes an issue with mixed-in methods: the mixin phase enters mixin methods only to class
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BackendReporting.scala b/src/compiler/scala/tools/nsc/backend/jvm/BackendReporting.scala
index be67da7137..89cbbc793c 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BackendReporting.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BackendReporting.scala
@@ -4,6 +4,7 @@ package backend.jvm
 import scala.tools.asm.tree.{AbstractInsnNode, MethodNode}
 import scala.tools.nsc.backend.jvm.BTypes.InternalName
 import scala.reflect.internal.util.Position
+import scala.tools.nsc.settings.ScalaSettings
 import scala.util.control.ControlThrowable
 
 /**
@@ -81,17 +82,15 @@ object BackendReporting {
    */
   def tryEither[A, B](op: => Either[A, B]): Either[A, B] = try { op } catch { case Invalid(e) => Left(e.asInstanceOf[A]) }
 
-  final case class WarnSettings(atInlineFailed: Boolean, noInlineMixed: Boolean, noInlineMissingBytecode: Boolean, noInlineMissingScalaInlineInfoAttr: Boolean)
-
   sealed trait OptimizerWarning {
-    def emitWarning(settings: WarnSettings): Boolean
+    def emitWarning(settings: ScalaSettings): Boolean
   }
 
   // Method filter in RightBiasedEither requires an implicit empty value. Taking the value here
   // in scope allows for-comprehensions that desugar into filter calls (for example when using a
   // tuple de-constructor).
   implicit object emptyOptimizerWarning extends OptimizerWarning {
-    def emitWarning(settings: WarnSettings): Boolean = false
+    def emitWarning(settings: ScalaSettings): Boolean = false
   }
 
   sealed trait MissingBytecodeWarning extends OptimizerWarning {
@@ -113,17 +112,17 @@ object BackendReporting {
           missingClass.map(c => s" Reason:\n$c").getOrElse("")
     }
 
-    def emitWarning(settings: WarnSettings): Boolean = this match {
+    def emitWarning(settings: ScalaSettings): Boolean = this match {
       case ClassNotFound(_, javaDefined) =>
-        if (javaDefined) settings.noInlineMixed
-        else settings.noInlineMissingBytecode
+        if (javaDefined) settings.YoptWarningNoInlineMixed
+        else settings.YoptWarningNoInlineMissingBytecode
 
       case m @ MethodNotFound(_, _, _, missing) =>
         if (m.isArrayMethod) false
-        else settings.noInlineMissingBytecode || missing.exists(_.emitWarning(settings))
+        else settings.YoptWarningNoInlineMissingBytecode || missing.exists(_.emitWarning(settings))
 
       case FieldNotFound(_, _, _, missing) =>
-        settings.noInlineMissingBytecode || missing.exists(_.emitWarning(settings))
+        settings.YoptWarningNoInlineMissingBytecode || missing.exists(_.emitWarning(settings))
     }
   }
 
@@ -142,9 +141,9 @@ object BackendReporting {
         s"Failed to get the type of class symbol $classFullName due to SI-9111."
     }
 
-    def emitWarning(settings: WarnSettings): Boolean = this match {
+    def emitWarning(settings: ScalaSettings): Boolean = this match {
       case NoClassBTypeInfoMissingBytecode(cause)         => cause.emitWarning(settings)
-      case NoClassBTypeInfoClassSymbolInfoFailedSI9111(_) => settings.noInlineMissingBytecode
+      case NoClassBTypeInfoClassSymbolInfoFailedSI9111(_) => settings.YoptWarningNoInlineMissingBytecode
     }
   }
 
@@ -176,11 +175,11 @@ object BackendReporting {
         cause.toString
     }
 
-    def emitWarning(settings: WarnSettings): Boolean = this match {
+    def emitWarning(settings: ScalaSettings): Boolean = this match {
       case MethodInlineInfoIncomplete(_, _, _, cause)               => cause.emitWarning(settings)
 
       case MethodInlineInfoMissing(_, _, _, Some(cause))            => cause.emitWarning(settings)
-      case MethodInlineInfoMissing(_, _, _, None)                   => settings.noInlineMissingBytecode
+      case MethodInlineInfoMissing(_, _, _, None)                   => settings.YoptWarningNoInlineMissingBytecode
 
       case MethodInlineInfoError(_, _, _, cause)                    => cause.emitWarning(settings)
 
@@ -217,9 +216,9 @@ object BackendReporting {
         s"Method $calleeMethodSig cannot be inlined because it is synchronized."
     }
 
-    def emitWarning(settings: WarnSettings): Boolean = this match {
+    def emitWarning(settings: ScalaSettings): Boolean = this match {
       case _: IllegalAccessInstruction | _: MethodWithHandlerCalledOnNonEmptyStack | _: SynchronizedMethod =>
-        settings.atInlineFailed
+        settings.YoptWarningEmitAtInlineFailed
 
       case IllegalAccessCheckFailed(_, _, _, _, _, cause) =>
         cause.emitWarning(settings)
@@ -251,11 +250,11 @@ object BackendReporting {
         s"Cannot read ScalaInlineInfo version $version in classfile $internalName. Use a more recent compiler."
     }
 
-    def emitWarning(settings: WarnSettings): Boolean = this match {
-      case NoInlineInfoAttribute(_)                             => settings.noInlineMissingScalaInlineInfoAttr
+    def emitWarning(settings: ScalaSettings): Boolean = this match {
+      case NoInlineInfoAttribute(_)                             => settings.YoptWarningNoInlineMissingScalaInlineInfoAttr
       case ClassNotFoundWhenBuildingInlineInfoFromSymbol(cause) => cause.emitWarning(settings)
-      case ClassSymbolInfoFailureSI9111(_)                      => settings.noInlineMissingBytecode
-      case UnknownScalaInlineInfoVersion(_, _)                  => settings.noInlineMissingScalaInlineInfoAttr
+      case ClassSymbolInfoFailureSI9111(_)                      => settings.YoptWarningNoInlineMissingBytecode
+      case UnknownScalaInlineInfoVersion(_, _)                  => settings.YoptWarningNoInlineMissingScalaInlineInfoAttr
     }
   }
 
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala
index 4bfd70bf1e..c6ee36d7b2 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala
@@ -14,7 +14,6 @@ import scala.reflect.internal.util.Statistics
 
 import scala.tools.asm
 import scala.tools.asm.tree.ClassNode
-import scala.tools.nsc.backend.jvm.opt.LocalOpt
 
 /*
  *  Prepare in-memory representations of classfiles using the ASM Tree API, and serialize them to disk.
@@ -215,9 +214,6 @@ abstract class GenBCode extends BCodeSyncAndTry {
      *          - converting the plain ClassNode to byte array and placing it on queue-3
      */
     class Worker2 {
-      // This instance is removed in a future commit that refactors LocalOpt
-      lazy val localOpt = new LocalOpt(settings, collection.mutable.Set())
-
       def runGlobalOptimizations(): Unit = {
         import scala.collection.convert.decorateAsScala._
         q2.asScala foreach {
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/CallGraph.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/CallGraph.scala
index cdd3f463de..028f0f8fa6 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/CallGraph.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/CallGraph.scala
@@ -43,7 +43,7 @@ class CallGraph[BT <: BTypes](val btypes: BT) {
         // callee, we only check there for the methodInlineInfo, we should find it there.
         calleeDeclarationClassBType.info.orThrow.inlineInfo.methodInfos.get(methodSignature) match {
           case Some(methodInlineInfo) =>
-            val canInlineFromSource = inlineGlobalEnabled || calleeSource == CompilationUnit
+            val canInlineFromSource = compilerSettings.YoptInlineGlobal || calleeSource == CompilationUnit
 
             val isAbstract = BytecodeUtils.isAbstractMethod(calleeMethodNode)
 
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
index 538b02cdbb..c827a097ea 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
@@ -16,7 +16,7 @@ import scala.collection.convert.decorateAsJava._
 import AsmUtils._
 import BytecodeUtils._
 import collection.mutable
-import scala.tools.asm.tree.analysis.{SourceInterpreter, Analyzer}
+import scala.tools.asm.tree.analysis.SourceInterpreter
 import BackendReporting._
 import scala.tools.nsc.backend.jvm.BTypes.InternalName
 
@@ -52,7 +52,7 @@ class Inliner[BT <: BTypes](val btypes: BT) {
           receiverKnownNotNull = false, keepLineNumbers = false)
 
         for (warning <- r) {
-          if ((callee.annotatedInline && btypes.warnSettings.atInlineFailed) || warning.emitWarning(warnSettings)) {
+          if ((callee.annotatedInline && btypes.compilerSettings.YoptWarningEmitAtInlineFailed) || warning.emitWarning(compilerSettings)) {
             val annotWarn = if (callee.annotatedInline) " is annotated @inline but" else ""
             val msg = s"${BackendReporting.methodSignature(callee.calleeDeclarationClass.internalName, callee.callee)}$annotWarn could not be inlined:\n$warning"
             backendReporting.inlinerWarning(request.callsitePosition, msg)
@@ -93,7 +93,7 @@ class Inliner[BT <: BTypes](val btypes: BT) {
         val res = doInlineCallsite(callsite)
 
         if (!res) {
-          if (annotatedInline && btypes.warnSettings.atInlineFailed) {
+          if (annotatedInline && btypes.compilerSettings.YoptWarningEmitAtInlineFailed) {
             // if the callsite is annotated @inline, we report an inline warning even if the underlying
             // reason is, for example, mixed compilation (which has a separate -Yopt-warning flag).
             def initMsg = s"${BackendReporting.methodSignature(calleeDeclClass.internalName, callee)} is annotated @inline but cannot be inlined"
@@ -104,7 +104,7 @@ class Inliner[BT <: BTypes](val btypes: BT) {
               backendReporting.inlinerWarning(pos, s"$initMsg: the method is not final and may be overridden." + warnMsg)
             else
               backendReporting.inlinerWarning(pos, s"$initMsg." + warnMsg)
-          } else if (warning.isDefined && warning.get.emitWarning(warnSettings)) {
+          } else if (warning.isDefined && warning.get.emitWarning(compilerSettings)) {
             // when annotatedInline is false, and there is some warning, the callsite metadata is possibly incomplete.
             backendReporting.inlinerWarning(pos, s"there was a problem determining if method ${callee.name} can be inlined: \n"+ warning.get)
           }
@@ -113,7 +113,7 @@ class Inliner[BT <: BTypes](val btypes: BT) {
         res
 
       case Callsite(ins, _, _, Left(warning), _, _, pos) =>
-        if (warning.emitWarning(warnSettings))
+        if (warning.emitWarning(compilerSettings))
           backendReporting.inlinerWarning(pos, s"failed to determine if ${ins.name} should be inlined:\n$warning")
         false
     }).toList
@@ -124,7 +124,7 @@ class Inliner[BT <: BTypes](val btypes: BT) {
    */
   def doInlineCallsite(callsite: Callsite): Boolean = callsite match {
     case Callsite(_, _, _, Right(Callee(callee, calleeDeclClass, safeToInline, _, annotatedInline, _, warning)), _, _, pos) =>
-      if (inliningHeuristics == "everything") safeToInline
+      if (compilerSettings.YoptInlineHeuristics.value == "everything") safeToInline
       else annotatedInline && safeToInline
 
     case _ => false
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala
index fb5cfeb167..5f51a94673 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala
@@ -14,7 +14,6 @@ import scala.tools.asm.tree._
 import scala.collection.convert.decorateAsScala._
 import scala.tools.nsc.backend.jvm.BTypes.InternalName
 import scala.tools.nsc.backend.jvm.opt.BytecodeUtils._
-import scala.tools.nsc.settings.ScalaSettings
 
 /**
  * Optimizations within a single method.
@@ -47,7 +46,10 @@ import scala.tools.nsc.settings.ScalaSettings
  * stale labels
  *   - eliminate labels that are not referenced, merge sequences of label definitions.
  */
-class LocalOpt(settings: ScalaSettings, unreachableCodeEliminated: collection.mutable.Set[MethodNode]) {
+class LocalOpt[BT <: BTypes](val btypes: BT) {
+  import LocalOptImpls._
+  import btypes._
+
   /**
    * Remove unreachable code from a method.
    *
@@ -88,7 +90,7 @@ class LocalOpt(settings: ScalaSettings, unreachableCodeEliminated: collection.mu
    * @return      `true` if unreachable code was eliminated in some method, `false` otherwise.
    */
   def methodOptimizations(clazz: ClassNode): Boolean = {
-    !settings.YoptNone && clazz.methods.asScala.foldLeft(false) {
+    !compilerSettings.YoptNone && clazz.methods.asScala.foldLeft(false) {
       case (changed, method) => methodOptimizations(method, clazz.name) || changed
     }
   }
@@ -137,7 +139,7 @@ class LocalOpt(settings: ScalaSettings, unreachableCodeEliminated: collection.mu
 
     def removalRound(): Boolean = {
       // unreachable-code, empty-handlers and simplify-jumps run until reaching a fixpoint (see doc on class LocalOpt)
-      val (codeRemoved, handlersRemoved, liveHandlerRemoved) = if (settings.YoptUnreachableCode) {
+      val (codeRemoved, handlersRemoved, liveHandlerRemoved) = if (compilerSettings.YoptUnreachableCode) {
         val (removedInstructions, liveLabels) = removeUnreachableCodeImpl(method, ownerClassName)
         val removedHandlers = removeEmptyExceptionHandlers(method)
         (removedInstructions.nonEmpty, removedHandlers.nonEmpty, removedHandlers.exists(h => liveLabels(h.start)))
@@ -145,7 +147,7 @@ class LocalOpt(settings: ScalaSettings, unreachableCodeEliminated: collection.mu
         (false, false, false)
       }
 
-      val jumpsChanged = if (settings.YoptSimplifyJumps) simplifyJumps(method) else false
+      val jumpsChanged = if (compilerSettings.YoptSimplifyJumps) simplifyJumps(method) else false
 
       // Eliminating live handlers and simplifying jump instructions may render more code
       // unreachable, so we need to run another round.
@@ -158,13 +160,13 @@ class LocalOpt(settings: ScalaSettings, unreachableCodeEliminated: collection.mu
 
     // (*) Removing stale local variable descriptors is required for correctness of unreachable-code
     val localsRemoved =
-      if (settings.YoptCompactLocals) compactLocalVariables(method) // also removes unused
-      else if (settings.YoptUnreachableCode) removeUnusedLocalVariableNodes(method)() // (*)
+      if (compilerSettings.YoptCompactLocals) compactLocalVariables(method) // also removes unused
+      else if (compilerSettings.YoptUnreachableCode) removeUnusedLocalVariableNodes(method)() // (*)
       else false
 
-    val lineNumbersRemoved = if (settings.YoptEmptyLineNumbers) removeEmptyLineNumbers(method) else false
+    val lineNumbersRemoved = if (compilerSettings.YoptEmptyLineNumbers) removeEmptyLineNumbers(method) else false
 
-    val labelsRemoved = if (settings.YoptEmptyLabels) removeEmptyLabelNodes(method) else false
+    val labelsRemoved = if (compilerSettings.YoptEmptyLabels) removeEmptyLabelNodes(method) else false
 
     // assert that local variable annotations are empty (we don't emit them) - otherwise we'd have
     // to eliminate those covering an empty range, similar to removeUnusedLocalVariableNodes.
@@ -177,6 +179,9 @@ class LocalOpt(settings: ScalaSettings, unreachableCodeEliminated: collection.mu
     codeHandlersOrJumpsChanged || localsRemoved || lineNumbersRemoved || labelsRemoved
   }
 
+}
+
+object LocalOptImpls {
   /**
    * Removes unreachable basic blocks.
    *
diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
index ee683418d9..9d7cf8cfaa 100644
--- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
@@ -282,6 +282,15 @@ trait ScalaSettings extends AbsScalaSettings
     else YinlinerWarnings.value = true
   })
 
+  def YoptWarningEmitAtInlineFailed =
+    !YoptWarnings.isSetByUser ||
+      YoptWarnings.contains(YoptWarningsChoices.atInlineFailedSummary) ||
+      YoptWarnings.contains(YoptWarningsChoices.atInlineFailed)
+
+  def YoptWarningNoInlineMixed                      = YoptWarnings.contains(YoptWarningsChoices.noInlineMixed)
+  def YoptWarningNoInlineMissingBytecode            = YoptWarnings.contains(YoptWarningsChoices.noInlineMissingBytecode)
+  def YoptWarningNoInlineMissingScalaInlineInfoAttr = YoptWarnings.contains(YoptWarningsChoices.noInlineMissingScalaInlineInfoAttr)
+
   private def removalIn212 = "This flag is scheduled for removal in 2.12. If you have a case where you need this flag then please report a bug."
 
   object YstatisticsPhases extends MultiChoiceEnumeration { val parser, typer, patmat, erasure, cleanup, jvm = Value }
diff --git a/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala b/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala
index 3ba3caa5e3..d0ffd06b01 100644
--- a/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala
+++ b/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala
@@ -8,7 +8,6 @@ import scala.reflect.io.VirtualDirectory
 import scala.tools.asm.Opcodes
 import scala.tools.asm.tree.{ClassNode, MethodNode}
 import scala.tools.cmd.CommandLineParser
-import scala.tools.nsc.backend.jvm.opt.LocalOpt
 import scala.tools.nsc.io.AbstractFile
 import scala.tools.nsc.reporters.StoreReporter
 import scala.tools.nsc.settings.MutableSettings
@@ -157,12 +156,6 @@ object CodeGenTools {
     assertTrue(h.start == insVec(startIndex) && h.end == insVec(endIndex) && h.handler == insVec(handlerIndex))
   }
 
-  val localOpt = {
-    val settings = new MutableSettings(msg => throw new IllegalArgumentException(msg))
-    settings.processArguments(List("-Yopt:l:method"), processAll = true)
-    new LocalOpt(settings, collection.mutable.Set())
-  }
-
   import scala.language.implicitConversions
 
   implicit def aliveInstruction(ins: Instruction): (Instruction, Boolean) = (ins, true)
diff --git a/test/junit/scala/tools/nsc/backend/jvm/opt/EmptyExceptionHandlersTest.scala b/test/junit/scala/tools/nsc/backend/jvm/opt/EmptyExceptionHandlersTest.scala
index 7b0504fec0..cb01f3d164 100644
--- a/test/junit/scala/tools/nsc/backend/jvm/opt/EmptyExceptionHandlersTest.scala
+++ b/test/junit/scala/tools/nsc/backend/jvm/opt/EmptyExceptionHandlersTest.scala
@@ -40,7 +40,7 @@ class EmptyExceptionHandlersTest extends ClearAfterClass {
       Op(RETURN)
     )
     assertTrue(convertMethod(asmMethod).handlers.length == 1)
-    localOpt.removeEmptyExceptionHandlers(asmMethod)
+    LocalOptImpls.removeEmptyExceptionHandlers(asmMethod)
     assertTrue(convertMethod(asmMethod).handlers.isEmpty)
   }
 
@@ -61,7 +61,7 @@ class EmptyExceptionHandlersTest extends ClearAfterClass {
       Op(RETURN)
     )
     assertTrue(convertMethod(asmMethod).handlers.length == 1)
-    localOpt.removeEmptyExceptionHandlers(asmMethod)
+    LocalOptImpls.removeEmptyExceptionHandlers(asmMethod)
     assertTrue(convertMethod(asmMethod).handlers.isEmpty)
   }
 
diff --git a/test/junit/scala/tools/nsc/backend/jvm/opt/EmptyLabelsAndLineNumbersTest.scala b/test/junit/scala/tools/nsc/backend/jvm/opt/EmptyLabelsAndLineNumbersTest.scala
index 8c0168826e..7283e20745 100644
--- a/test/junit/scala/tools/nsc/backend/jvm/opt/EmptyLabelsAndLineNumbersTest.scala
+++ b/test/junit/scala/tools/nsc/backend/jvm/opt/EmptyLabelsAndLineNumbersTest.scala
@@ -42,14 +42,14 @@ class EmptyLabelsAndLineNumbersTest {
     )
 
     val method = genMethod()(ops.map(_._1): _*)
-    assertTrue(localOpt.removeEmptyLineNumbers(method))
+    assertTrue(LocalOptImpls.removeEmptyLineNumbers(method))
     assertSameCode(instructionsFromMethod(method), ops.filter(_._2).map(_._1))
   }
 
   @Test
   def badlyLocatedLineNumbers(): Unit = {
     def t(ops: Instruction*) =
-      assertThrows[AssertionError](localOpt.removeEmptyLineNumbers(genMethod()(ops: _*)))
+      assertThrows[AssertionError](LocalOptImpls.removeEmptyLineNumbers(genMethod()(ops: _*)))
 
     // line numbers have to be right after their referenced label node
     t(LineNumber(0, Label(1)), Label(1))
@@ -88,7 +88,7 @@ class EmptyLabelsAndLineNumbersTest {
     )
 
     val method = genMethod(handlers = handler)(ops(2, 3, 8, 8, 9, 11).map(_._1): _*)
-    assertTrue(localOpt.removeEmptyLabelNodes(method))
+    assertTrue(LocalOptImpls.removeEmptyLabelNodes(method))
     val m = convertMethod(method)
     assertSameCode(m.instructions, ops(1, 1, 7, 7, 7, 10).filter(_._2).map(_._1))
     assertTrue(m.handlers match {
diff --git a/test/junit/scala/tools/nsc/backend/jvm/opt/InlinerTest.scala b/test/junit/scala/tools/nsc/backend/jvm/opt/InlinerTest.scala
index d113598ce5..17724aecb1 100644
--- a/test/junit/scala/tools/nsc/backend/jvm/opt/InlinerTest.scala
+++ b/test/junit/scala/tools/nsc/backend/jvm/opt/InlinerTest.scala
@@ -152,7 +152,7 @@ class InlinerTest extends ClearAfterClass {
 
     assertSameCode(convertMethod(g).instructions.dropNonOp.take(4), expectedInlined)
 
-    localOpt.methodOptimizations(g, "C")
+    compiler.genBCode.bTypes.localOpt.methodOptimizations(g, "C")
     assertSameCode(convertMethod(g).instructions.dropNonOp,
       expectedInlined ++ List(VarOp(ASTORE, 2), VarOp(ALOAD, 2), Op(ATHROW)))
   }
diff --git a/test/junit/scala/tools/nsc/backend/jvm/opt/SimplifyJumpsTest.scala b/test/junit/scala/tools/nsc/backend/jvm/opt/SimplifyJumpsTest.scala
index 360fa1d23d..a685ae7dd5 100644
--- a/test/junit/scala/tools/nsc/backend/jvm/opt/SimplifyJumpsTest.scala
+++ b/test/junit/scala/tools/nsc/backend/jvm/opt/SimplifyJumpsTest.scala
@@ -26,7 +26,7 @@ class SimplifyJumpsTest {
       Op(RETURN)
     )
     val method = genMethod()(ops: _*)
-    assertTrue(localOpt.simplifyJumps(method))
+    assertTrue(LocalOptImpls.simplifyJumps(method))
     assertSameCode(instructionsFromMethod(method), Op(RETURN) :: ops.tail)
   }
 
@@ -45,7 +45,7 @@ class SimplifyJumpsTest {
       Jump(GOTO, Label(2)) :: // replaced by ATHROW
       rest: _*
     )
-    assertTrue(localOpt.simplifyJumps(method))
+    assertTrue(LocalOptImpls.simplifyJumps(method))
     assertSameCode(instructionsFromMethod(method), Op(ACONST_NULL) :: Op(ATHROW) :: rest)
   }
 
@@ -66,11 +66,11 @@ class SimplifyJumpsTest {
       Op(RETURN)
     )
     val method = genMethod(handlers = handler)(initialInstrs: _*)
-    assertFalse(localOpt.simplifyJumps(method))
+    assertFalse(LocalOptImpls.simplifyJumps(method))
     assertSameCode(instructionsFromMethod(method), initialInstrs)
 
     val optMethod = genMethod()(initialInstrs: _*) // no handler
-    assertTrue(localOpt.simplifyJumps(optMethod))
+    assertTrue(LocalOptImpls.simplifyJumps(optMethod))
     assertSameCode(instructionsFromMethod(optMethod).take(3), List(Label(1), Op(ACONST_NULL), Op(ATHROW)))
   }
 
@@ -91,7 +91,7 @@ class SimplifyJumpsTest {
       Op(IRETURN)
     )
     val method = genMethod()(begin ::: rest: _*)
-    assertTrue(localOpt.simplifyJumps(method))
+    assertTrue(LocalOptImpls.simplifyJumps(method))
     assertSameCode(
       instructionsFromMethod(method),
       List(VarOp(ILOAD, 1), Jump(IFLT, Label(3))) ::: rest.tail )
@@ -99,7 +99,7 @@ class SimplifyJumpsTest {
     // no label allowed between begin and rest. if there's another label, then there could be a
     // branch that label. eliminating the  GOTO would change the behavior.
     val nonOptMethod = genMethod()(begin ::: Label(22) :: rest: _*)
-    assertFalse(localOpt.simplifyJumps(nonOptMethod))
+    assertFalse(LocalOptImpls.simplifyJumps(nonOptMethod))
   }
 
   @Test
@@ -116,7 +116,7 @@ class SimplifyJumpsTest {
     // ensures that the goto is safely removed. ASM supports removing while iterating, but not the
     // next element of the current. Here, the current is the IFGE, the next is the GOTO.
     val method = genMethod()(code(Jump(IFGE, Label(2)), Jump(GOTO, Label(3))): _*)
-    assertTrue(localOpt.simplifyJumps(method))
+    assertTrue(LocalOptImpls.simplifyJumps(method))
     assertSameCode(instructionsFromMethod(method), code(Jump(IFLT, Label(3))))
   }
 
@@ -131,7 +131,7 @@ class SimplifyJumpsTest {
       Op(IRETURN)
     )
     val method = genMethod()(ops: _*)
-    assertTrue(localOpt.simplifyJumps(method))
+    assertTrue(LocalOptImpls.simplifyJumps(method))
     assertSameCode(instructionsFromMethod(method), ops.tail)
   }
 
@@ -157,7 +157,7 @@ class SimplifyJumpsTest {
       Op(IRETURN)
     )
     val method = genMethod()(ops(1, 2, 3): _*)
-    assertTrue(localOpt.simplifyJumps(method))
+    assertTrue(LocalOptImpls.simplifyJumps(method))
     assertSameCode(instructionsFromMethod(method), ops(3, 3, 3))
   }
 
@@ -181,7 +181,7 @@ class SimplifyJumpsTest {
     )
 
     val method = genMethod()(ops(2): _*)
-    assertTrue(localOpt.simplifyJumps(method))
+    assertTrue(LocalOptImpls.simplifyJumps(method))
     assertSameCode(instructionsFromMethod(method), ops(3))
   }
 
@@ -202,7 +202,7 @@ class SimplifyJumpsTest {
     )
 
     val method = genMethod()(ops(Jump(IFGE, Label(1))): _*)
-    assertTrue(localOpt.simplifyJumps(method))
+    assertTrue(LocalOptImpls.simplifyJumps(method))
     assertSameCode(instructionsFromMethod(method), ops(Op(POP)))
   }
 
@@ -215,7 +215,7 @@ class SimplifyJumpsTest {
       Jump(GOTO, Label(1))
     )
     val method = genMethod()(ops(List(Jump(IF_ICMPGE, Label(1)))): _*)
-    assertTrue(localOpt.simplifyJumps(method))
+    assertTrue(LocalOptImpls.simplifyJumps(method))
     assertSameCode(instructionsFromMethod(method), ops(List(Op(POP), Op(POP))))
   }
 }
diff --git a/test/junit/scala/tools/nsc/backend/jvm/opt/UnreachableCodeTest.scala b/test/junit/scala/tools/nsc/backend/jvm/opt/UnreachableCodeTest.scala
index da9853148b..902af7b7fa 100644
--- a/test/junit/scala/tools/nsc/backend/jvm/opt/UnreachableCodeTest.scala
+++ b/test/junit/scala/tools/nsc/backend/jvm/opt/UnreachableCodeTest.scala
@@ -44,7 +44,7 @@ class UnreachableCodeTest extends ClearAfterClass {
 
   def assertEliminateDead(code: (Instruction, Boolean)*): Unit = {
     val method = genMethod()(code.map(_._1): _*)
-    localOpt.removeUnreachableCodeImpl(method, "C")
+    LocalOptImpls.removeUnreachableCodeImpl(method, "C")
     val nonEliminated = instructionsFromMethod(method)
     val expectedLive = code.filter(_._2).map(_._1).toList
     assertSameCode(nonEliminated, expectedLive)
-- 
cgit v1.2.3


From 09f5752b871a2e870dfc1bb57fda203515d26651 Mon Sep 17 00:00:00 2001
From: Lukas Rytz <lukas.rytz@gmail.com>
Date: Mon, 30 Mar 2015 14:30:30 +0200
Subject: Apply local variable index shift when inlining iinc instruction

That was an oversight. Scalac never emits iinc, but it can appear when
inlining from the classpath.
---
 src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala | 1 +
 1 file changed, 1 insertion(+)

(limited to 'src/compiler')

diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
index c827a097ea..1a51063231 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
@@ -332,6 +332,7 @@ class Inliner[BT <: BTypes](val btypes: BT) {
       val localVarShift = callsiteMethod.maxLocals
       clonedInstructions.iterator.asScala foreach {
         case varInstruction: VarInsnNode => varInstruction.`var` += localVarShift
+        case iinc: IincInsnNode          => iinc.`var` += localVarShift
         case _ => ()
       }
 
-- 
cgit v1.2.3


From a40ee59d4455c2bb45168844f50e9d15120bd7d8 Mon Sep 17 00:00:00 2001
From: Lukas Rytz <lukas.rytz@gmail.com>
Date: Tue, 31 Mar 2015 13:35:42 +0200
Subject: Don't force the GenASM backend when passing -optimize

This behavior is confusing and also problematic for writing partest
tests: CI passes -optimize, which negates the -Ybackend:GenBCode entry
in a flags file.
---
 src/compiler/scala/tools/nsc/Reporting.scala              | 2 +-
 src/compiler/scala/tools/nsc/settings/ScalaSettings.scala | 7 +------
 test/files/neg/case-collision2.flags                      | 2 +-
 test/files/run/t7407.flags                                | 2 +-
 test/files/run/t7407b.flags                               | 2 +-
 test/files/run/t8845.flags                                | 2 +-
 test/files/run/t8925.flags                                | 2 +-
 7 files changed, 7 insertions(+), 12 deletions(-)

(limited to 'src/compiler')

diff --git a/src/compiler/scala/tools/nsc/Reporting.scala b/src/compiler/scala/tools/nsc/Reporting.scala
index 72a4b69536..4e7a527a5a 100644
--- a/src/compiler/scala/tools/nsc/Reporting.scala
+++ b/src/compiler/scala/tools/nsc/Reporting.scala
@@ -46,7 +46,7 @@ trait Reporting extends scala.reflect.internal.Reporting { self: ast.Positions w
     private val _deprecationWarnings    = new ConditionalWarning("deprecation", settings.deprecation)()
     private val _uncheckedWarnings      = new ConditionalWarning("unchecked", settings.unchecked)()
     private val _featureWarnings        = new ConditionalWarning("feature", settings.feature)()
-    private val _inlinerWarnings        = new ConditionalWarning("inliner", settings.YinlinerWarnings)(if (settings.isBCodeAskedFor) settings.YoptWarnings.name else settings.YinlinerWarnings.name)
+    private val _inlinerWarnings        = new ConditionalWarning("inliner", settings.YinlinerWarnings)(if (settings.isBCodeActive) settings.YoptWarnings.name else settings.YinlinerWarnings.name)
     private val _allConditionalWarnings = List(_deprecationWarnings, _uncheckedWarnings, _featureWarnings, _inlinerWarnings)
 
     // TODO: remove in favor of the overload that takes a Symbol, give that argument a default (NoSymbol)
diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
index 9d7cf8cfaa..03fd0976e5 100644
--- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
@@ -361,12 +361,7 @@ trait ScalaSettings extends AbsScalaSettings
   /** Test whether this is scaladoc we're looking at */
   def isScaladoc = false
 
-  /**
-   * Helper utilities for use by checkConflictingSettings()
-   */
-  def isBCodeActive   = !isICodeAskedFor
-  def isBCodeAskedFor = (Ybackend.value != "GenASM")
-  def isICodeAskedFor = ((Ybackend.value == "GenASM") || optimiseSettings.exists(_.value) || writeICode.isSetByUser)
+  def isBCodeActive = Ybackend.value == "GenBCode"
 
   object MacroExpand {
     val None = "none"
diff --git a/test/files/neg/case-collision2.flags b/test/files/neg/case-collision2.flags
index 5bfa9da5c5..bea46902c9 100644
--- a/test/files/neg/case-collision2.flags
+++ b/test/files/neg/case-collision2.flags
@@ -1 +1 @@
--Ynooptimize -Ybackend:GenBCode -Xfatal-warnings
+-Ybackend:GenBCode -Xfatal-warnings
diff --git a/test/files/run/t7407.flags b/test/files/run/t7407.flags
index be4ef0798a..ffc65f4b81 100644
--- a/test/files/run/t7407.flags
+++ b/test/files/run/t7407.flags
@@ -1 +1 @@
--Ynooptimise -Yopt:l:none -Ybackend:GenBCode
+-Yopt:l:none -Ybackend:GenBCode
diff --git a/test/files/run/t7407b.flags b/test/files/run/t7407b.flags
index c8547a27dc..c30091d3de 100644
--- a/test/files/run/t7407b.flags
+++ b/test/files/run/t7407b.flags
@@ -1 +1 @@
--Ynooptimise -Ybackend:GenBCode
+-Ybackend:GenBCode
diff --git a/test/files/run/t8845.flags b/test/files/run/t8845.flags
index aada25f80d..c30091d3de 100644
--- a/test/files/run/t8845.flags
+++ b/test/files/run/t8845.flags
@@ -1 +1 @@
--Ybackend:GenBCode -Ynooptimize
+-Ybackend:GenBCode
diff --git a/test/files/run/t8925.flags b/test/files/run/t8925.flags
index be4ef0798a..ffc65f4b81 100644
--- a/test/files/run/t8925.flags
+++ b/test/files/run/t8925.flags
@@ -1 +1 @@
--Ynooptimise -Yopt:l:none -Ybackend:GenBCode
+-Yopt:l:none -Ybackend:GenBCode
-- 
cgit v1.2.3


From 323d044f93242cb023042c37b64ce79c5810e612 Mon Sep 17 00:00:00 2001
From: Lukas Rytz <lukas.rytz@gmail.com>
Date: Mon, 30 Mar 2015 21:40:40 +0200
Subject: Don't inlinie if the resulting method becomes too large for the JVM

This threshold is really the last resort and should never be reached.
An inlining heuristic that blows up methods to the maximum size
allowed by the JVM is broken.

In the future we need to include some heuristic about code size when
making an inlining decision, see github.com/scala-opt/scala/issues/2
---
 .../tools/nsc/backend/jvm/BackendReporting.scala   |  9 +++++++-
 .../tools/nsc/backend/jvm/opt/BytecodeUtils.scala  | 24 +++++++++++++++++++++-
 .../scala/tools/nsc/backend/jvm/opt/Inliner.scala  |  6 +++++-
 test/files/neg/inlineMaxSize.check                 |  9 ++++++++
 test/files/neg/inlineMaxSize.flags                 |  1 +
 test/files/neg/inlineMaxSize.scala                 |  8 ++++++++
 6 files changed, 54 insertions(+), 3 deletions(-)
 create mode 100644 test/files/neg/inlineMaxSize.check
 create mode 100644 test/files/neg/inlineMaxSize.flags
 create mode 100644 test/files/neg/inlineMaxSize.scala

(limited to 'src/compiler')

diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BackendReporting.scala b/src/compiler/scala/tools/nsc/backend/jvm/BackendReporting.scala
index 89cbbc793c..c15ed032fb 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BackendReporting.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BackendReporting.scala
@@ -214,10 +214,15 @@ object BackendReporting {
 
       case SynchronizedMethod(_, _, _) =>
         s"Method $calleeMethodSig cannot be inlined because it is synchronized."
+
+      case ResultingMethodTooLarge(_, _, _, callsiteClass, callsiteName, callsiteDesc) =>
+        s"""The size of the callsite method ${BackendReporting.methodSignature(callsiteClass, callsiteName, callsiteDesc)}
+           |would exceed the JVM method size limit after inlining $calleeMethodSig.
+         """.stripMargin
     }
 
     def emitWarning(settings: ScalaSettings): Boolean = this match {
-      case _: IllegalAccessInstruction | _: MethodWithHandlerCalledOnNonEmptyStack | _: SynchronizedMethod =>
+      case _: IllegalAccessInstruction | _: MethodWithHandlerCalledOnNonEmptyStack | _: SynchronizedMethod | _: ResultingMethodTooLarge =>
         settings.YoptWarningEmitAtInlineFailed
 
       case IllegalAccessCheckFailed(_, _, _, _, _, cause) =>
@@ -231,6 +236,8 @@ object BackendReporting {
   case class MethodWithHandlerCalledOnNonEmptyStack(calleeDeclarationClass: InternalName, name: String, descriptor: String,
                                                     callsiteClass: InternalName, callsiteName: String, callsiteDesc: String) extends CannotInlineWarning
   case class SynchronizedMethod(calleeDeclarationClass: InternalName, name: String, descriptor: String) extends CannotInlineWarning
+  case class ResultingMethodTooLarge(calleeDeclarationClass: InternalName, name: String, descriptor: String,
+                                     callsiteClass: InternalName, callsiteName: String, callsiteDesc: String) extends CannotInlineWarning
 
   /**
    * Used in the InlineInfo of a ClassBType, when some issue occurred obtaining the inline information.
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala
index a295bc49b1..fe1dbe682b 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala
@@ -10,6 +10,7 @@ package opt
 import scala.annotation.{tailrec, switch}
 import scala.collection.mutable
 import scala.reflect.internal.util.Collections._
+import scala.tools.asm.commons.CodeSizeEvaluator
 import scala.tools.asm.tree.analysis._
 import scala.tools.asm.{MethodWriter, ClassWriter, Label, Opcodes}
 import scala.tools.asm.tree._
@@ -21,6 +22,12 @@ import scala.tools.nsc.backend.jvm.BTypes._
 
 object BytecodeUtils {
 
+  // http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.9.1
+  final val maxJVMMethodSize         = 65535
+
+  // 5% margin, more than enough for the instructions added by the inliner (store / load args, null check for instance methods)
+  final val maxMethodSizeAfterInline = maxJVMMethodSize - (maxJVMMethodSize / 20)
+
   object Goto {
     def unapply(instruction: AbstractInsnNode): Option[JumpInsnNode] = {
       if (instruction.getOpcode == Opcodes.GOTO) Some(instruction.asInstanceOf[JumpInsnNode])
@@ -217,7 +224,7 @@ object BytecodeUtils {
    * to create a separate visitor for computing those values, duplicating the functionality from the
    * MethodWriter.
    */
-  def computeMaxLocalsMaxStack(method: MethodNode) {
+  def computeMaxLocalsMaxStack(method: MethodNode): Unit = {
     val cw = new ClassWriter(ClassWriter.COMPUTE_MAXS)
     val excs = method.exceptions.asScala.toArray
     val mw = cw.visitMethod(method.access, method.name, method.desc, method.signature, excs).asInstanceOf[MethodWriter]
@@ -226,6 +233,21 @@ object BytecodeUtils {
     method.maxStack = mw.getMaxStack
   }
 
+  def codeSizeOKForInlining(caller: MethodNode, callee: MethodNode): Boolean = {
+    // Looking at the implementation of CodeSizeEvaluator, all instructions except tableswitch and
+    // lookupswitch are <= 8 bytes. These should be rare enough for 8 to be an OK rough upper bound.
+    def roughUpperBound(methodNode: MethodNode): Int = methodNode.instructions.size * 8
+
+    def maxSize(methodNode: MethodNode): Int = {
+      val eval = new CodeSizeEvaluator(null)
+      methodNode.accept(eval)
+      eval.getMaxSize
+    }
+
+    (roughUpperBound(caller) + roughUpperBound(callee) > maxMethodSizeAfterInline) &&
+      (maxSize(caller) + maxSize(callee) > maxMethodSizeAfterInline)
+  }
+
   def removeLineNumberNodes(classNode: ClassNode): Unit = {
     for (m <- classNode.methods.asScala) removeLineNumberNodes(m.instructions)
   }
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
index 1a51063231..fd2a2e1b26 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
@@ -497,7 +497,11 @@ class Inliner[BT <: BTypes](val btypes: BT) {
       callsiteStackHeight > expectedArgs
     }
 
-    if (isSynchronizedMethod(callee)) {
+    if (codeSizeOKForInlining(callsiteMethod, callee)) {
+      Some(ResultingMethodTooLarge(
+        calleeDeclarationClass.internalName, callee.name, callee.desc,
+        callsiteClass.internalName, callsiteMethod.name, callsiteMethod.desc))
+    } else if (isSynchronizedMethod(callee)) {
       // Could be done by locking on the receiver, wrapping the inlined code in a try and unlocking
       // in finally. But it's probably not worth the effort, scala never emits synchronized methods.
       Some(SynchronizedMethod(calleeDeclarationClass.internalName, callee.name, callee.desc))
diff --git a/test/files/neg/inlineMaxSize.check b/test/files/neg/inlineMaxSize.check
new file mode 100644
index 0000000000..d218a8b6e2
--- /dev/null
+++ b/test/files/neg/inlineMaxSize.check
@@ -0,0 +1,9 @@
+inlineMaxSize.scala:7: warning: C::i()I is annotated @inline but could not be inlined:
+The size of the callsite method C::j()I
+would exceed the JVM method size limit after inlining C::i()I.
+
+  @inline final def j = i + i
+                            ^
+error: No warnings can be incurred under -Xfatal-warnings.
+one warning found
+one error found
diff --git a/test/files/neg/inlineMaxSize.flags b/test/files/neg/inlineMaxSize.flags
new file mode 100644
index 0000000000..9c6b811622
--- /dev/null
+++ b/test/files/neg/inlineMaxSize.flags
@@ -0,0 +1 @@
+-Ybackend:GenBCode -Ydelambdafy:method -Yopt:l:classpath -Yopt-warnings -Xfatal-warnings
\ No newline at end of file
diff --git a/test/files/neg/inlineMaxSize.scala b/test/files/neg/inlineMaxSize.scala
new file mode 100644
index 0000000000..16dc0d9538
--- /dev/null
+++ b/test/files/neg/inlineMaxSize.scala
@@ -0,0 +1,8 @@
+// not a JUnit test because of https://github.com/scala-opt/scala/issues/23
+class C {
+  @inline final def f = 0
+  @inline final def g = f + f + f + f + f + f + f + f + f + f
+  @inline final def h = g + g + g + g + g + g + g + g + g + g
+  @inline final def i = h + h + h + h + h + h + h + h + h + h
+  @inline final def j = i + i
+}
-- 
cgit v1.2.3


From 6becefe90690ae025308b00e0fd7e46646b4f961 Mon Sep 17 00:00:00 2001
From: Lukas Rytz <lukas.rytz@gmail.com>
Date: Tue, 31 Mar 2015 20:02:28 +0200
Subject: SI-9139 don't inline across @strictfp modes

Cannot inline if one of the methods is @strictfp, but not the other.
---
 .../tools/nsc/backend/jvm/BackendReporting.scala    |  9 ++++++++-
 .../tools/nsc/backend/jvm/opt/BytecodeUtils.scala   |  2 ++
 .../scala/tools/nsc/backend/jvm/opt/Inliner.scala   |  4 ++++
 .../nsc/backend/jvm/opt/InlineWarningTest.scala     | 21 +++++++++++++++++++++
 4 files changed, 35 insertions(+), 1 deletion(-)

(limited to 'src/compiler')

diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BackendReporting.scala b/src/compiler/scala/tools/nsc/backend/jvm/BackendReporting.scala
index c15ed032fb..d641f708d2 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BackendReporting.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BackendReporting.scala
@@ -215,6 +215,11 @@ object BackendReporting {
       case SynchronizedMethod(_, _, _) =>
         s"Method $calleeMethodSig cannot be inlined because it is synchronized."
 
+      case StrictfpMismatch(_, _, _, callsiteClass, callsiteName, callsiteDesc) =>
+        s"""The callsite method ${BackendReporting.methodSignature(callsiteClass, callsiteName, callsiteDesc)}
+           |does not have the same strictfp mode as the callee $calleeMethodSig.
+         """.stripMargin
+
       case ResultingMethodTooLarge(_, _, _, callsiteClass, callsiteName, callsiteDesc) =>
         s"""The size of the callsite method ${BackendReporting.methodSignature(callsiteClass, callsiteName, callsiteDesc)}
            |would exceed the JVM method size limit after inlining $calleeMethodSig.
@@ -222,7 +227,7 @@ object BackendReporting {
     }
 
     def emitWarning(settings: ScalaSettings): Boolean = this match {
-      case _: IllegalAccessInstruction | _: MethodWithHandlerCalledOnNonEmptyStack | _: SynchronizedMethod | _: ResultingMethodTooLarge =>
+      case _: IllegalAccessInstruction | _: MethodWithHandlerCalledOnNonEmptyStack | _: SynchronizedMethod | _: StrictfpMismatch | _: ResultingMethodTooLarge =>
         settings.YoptWarningEmitAtInlineFailed
 
       case IllegalAccessCheckFailed(_, _, _, _, _, cause) =>
@@ -236,6 +241,8 @@ object BackendReporting {
   case class MethodWithHandlerCalledOnNonEmptyStack(calleeDeclarationClass: InternalName, name: String, descriptor: String,
                                                     callsiteClass: InternalName, callsiteName: String, callsiteDesc: String) extends CannotInlineWarning
   case class SynchronizedMethod(calleeDeclarationClass: InternalName, name: String, descriptor: String) extends CannotInlineWarning
+  case class StrictfpMismatch(calleeDeclarationClass: InternalName, name: String, descriptor: String,
+                              callsiteClass: InternalName, callsiteName: String, callsiteDesc: String) extends CannotInlineWarning
   case class ResultingMethodTooLarge(calleeDeclarationClass: InternalName, name: String, descriptor: String,
                                      callsiteClass: InternalName, callsiteName: String, callsiteDesc: String) extends CannotInlineWarning
 
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala
index fe1dbe682b..201ab15177 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala
@@ -96,6 +96,8 @@ object BytecodeUtils {
 
   def isFinalMethod(methodNode: MethodNode): Boolean = (methodNode.access & (Opcodes.ACC_FINAL | Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC)) != 0
 
+  def isStrictfpMethod(methodNode: MethodNode): Boolean = (methodNode.access & Opcodes.ACC_STRICT) != 0
+
   def nextExecutableInstruction(instruction: AbstractInsnNode, alsoKeep: AbstractInsnNode => Boolean = Set()): Option[AbstractInsnNode] = {
     var result = instruction
     do { result = result.getNext }
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
index fd2a2e1b26..ac5c9ce2e6 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
@@ -505,6 +505,10 @@ class Inliner[BT <: BTypes](val btypes: BT) {
       // Could be done by locking on the receiver, wrapping the inlined code in a try and unlocking
       // in finally. But it's probably not worth the effort, scala never emits synchronized methods.
       Some(SynchronizedMethod(calleeDeclarationClass.internalName, callee.name, callee.desc))
+    } else if (isStrictfpMethod(callsiteMethod) != isStrictfpMethod(callee)) {
+      Some(StrictfpMismatch(
+        calleeDeclarationClass.internalName, callee.name, callee.desc,
+        callsiteClass.internalName, callsiteMethod.name, callsiteMethod.desc))
     } else if (!callee.tryCatchBlocks.isEmpty && stackHasNonParameters) {
       Some(MethodWithHandlerCalledOnNonEmptyStack(
         calleeDeclarationClass.internalName, callee.name, callee.desc,
diff --git a/test/junit/scala/tools/nsc/backend/jvm/opt/InlineWarningTest.scala b/test/junit/scala/tools/nsc/backend/jvm/opt/InlineWarningTest.scala
index 5b47475863..029caa995c 100644
--- a/test/junit/scala/tools/nsc/backend/jvm/opt/InlineWarningTest.scala
+++ b/test/junit/scala/tools/nsc/backend/jvm/opt/InlineWarningTest.scala
@@ -170,4 +170,25 @@ class InlineWarningTest extends ClearAfterClass {
     compile(code, allowMessage = i => { c += 1; i.msg contains warn })
     assert(c == 1, c)
   }
+
+  @Test
+  def cannotMixStrictfp(): Unit = {
+    val code =
+      """import annotation.strictfp
+        |class C {
+        |  @strictfp @inline final def f = 0
+        |  @strictfp def t1 = f
+        |  def t2 = f
+        |}
+      """.stripMargin
+
+    val warn =
+      """C::f()I is annotated @inline but could not be inlined:
+        |The callsite method C::t2()I
+        |does not have the same strictfp mode as the callee C::f()I.""".stripMargin
+
+    var c = 0
+    compile(code, allowMessage = i => { c += 1; i.msg contains warn })
+    assert(c == 1, c)
+  }
 }
-- 
cgit v1.2.3