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).
---
 test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala  |  2 +-
 .../scala/tools/nsc/backend/jvm/opt/InlinerTest.scala      | 14 ++++++++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)

(limited to 'test/junit')

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 'test/junit')

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 'test/junit')

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 a5dc9b7913c113ffd15b1f23cba2a4a710546cd8 Mon Sep 17 00:00:00 2001
From: Lukas Rytz <lukas.rytz@gmail.com>
Date: Mon, 30 Mar 2015 21:40:53 +0200
Subject: Test case: cannot inline a private call into a different class.

Invocations of private methods cannot be inlined into a different
class, this would cause an IllegalAccessError.
---
 .../nsc/backend/jvm/opt/InlineWarningTest.scala    | 27 ++++++++++++++++++++++
 1 file changed, 27 insertions(+)

(limited to 'test/junit')

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 fedc074a15..5b47475863 100644
--- a/test/junit/scala/tools/nsc/backend/jvm/opt/InlineWarningTest.scala
+++ b/test/junit/scala/tools/nsc/backend/jvm/opt/InlineWarningTest.scala
@@ -143,4 +143,31 @@ class InlineWarningTest extends ClearAfterClass {
     compileClasses(newCompiler(extraArgs = InlineWarningTest.argsNoWarn + " -Yopt-warnings:no-inline-mixed"))(scalaCode, List((javaCode, "A.java")), allowMessage = i => {c += 1; warns.exists(i.msg contains _)})
     assert(c == 2, c)
   }
+
+  @Test
+  def cannotInlinePrivateCallIntoDifferentClass(): Unit = {
+    val code =
+      """class M {
+        |  @inline final def f = {
+        |    @noinline def nested = 0
+        |    nested
+        |  }
+        |
+        |  def t = f // ok
+        |}
+        |
+        |class N {
+        |  def t(a: M) = a.f // not possible
+        |}
+      """.stripMargin
+
+    val warn =
+      """M::f()I is annotated @inline but could not be inlined:
+        |The callee M::f()I contains the instruction INVOKESPECIAL M.nested$1 ()I
+        |that would cause an IllegalAccessError when inlined into class N""".stripMargin
+
+    var c = 0
+    compile(code, allowMessage = i => { c += 1; i.msg contains warn })
+    assert(c == 1, c)
+  }
 }
-- 
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 'test/junit')

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