diff options
3 files changed, 42 insertions, 39 deletions
diff --git a/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala b/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala index ed76e66aa0..aa53a22ade 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala @@ -16,6 +16,7 @@ import scala.tools.nsc.util.{Position,NoPosition} A pattern match case THIS(clasz) => + case STORE_THIS(kind) => case CONSTANT(const) => case LOAD_ARRAY_ITEM(kind) => case LOAD_LOCAL(local) => @@ -40,6 +41,8 @@ import scala.tools.nsc.util.{Position,NoPosition} case DUP(kind) => case MONITOR_ENTER() => case MONITOR_EXIT() => + case BOX(boxType) => + case UNBOX(tpe) => case SCOPE_ENTER(lv) => case SCOPE_EXIT(lv) => case LOAD_EXCEPTION() => diff --git a/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala index 69bcae5312..70bea2d44a 100644 --- a/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala +++ b/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala @@ -24,7 +24,37 @@ abstract class ClosureElimination extends SubComponent { /** Create a new phase */ override def newPhase(p: Phase) = new ClosureEliminationPhase(p) - /** The Inlining phase. + /** A simple peephole optimizer. */ + val peephole = new PeepholeOpt( (i1, i2) => + (i1, i2) match { + case (CONSTANT(c), DROP(_)) => + if (c.tag == UnitTag) + Some(List(i2)) + else + Some(Nil); + + case (LOAD_LOCAL(x), STORE_LOCAL(y)) => + if (x eq y) Some(Nil) else None + + case (STORE_LOCAL(x), LOAD_LOCAL(y)) if (x == y) => + Some(List(DUP(x.kind), STORE_LOCAL(x))) + + case (LOAD_LOCAL(_), DROP(_)) | (DUP(_), DROP(_)) => + Some(Nil) + + case (BOX(t1), UNBOX(t2)) if (t1 == t2) => + Some(Nil) + + case (LOAD_FIELD(sym, isStatic), DROP(_)) if !sym.hasAnnotation(definitions.VolatileAttr) => + if (isStatic) + Some(Nil) + else + Some(DROP(REFERENCE(definitions.ObjectClass)) :: Nil); + + case _ => None + }); + + /** The closure elimination phase. */ class ClosureEliminationPhase(prev: Phase) extends ICodePhase(prev) { @@ -52,36 +82,6 @@ abstract class ClosureElimination extends SubComponent { ret } - /** A simple peephole optimizer. */ - val peephole = new PeepholeOpt( (i1, i2) => - (i1, i2) match { - case (CONSTANT(c), DROP(_)) => - if (c.tag == UnitTag) - Some(List(i2)) - else - Some(Nil); - - case (LOAD_LOCAL(x), STORE_LOCAL(y)) => - if (x eq y) Some(Nil) else None - -// case (STORE_LOCAL(x), LOAD_LOCAL(y)) if (x == y) => -// Some(List(DUP(x.kind), STORE_LOCAL(x))) - - case (LOAD_LOCAL(_), DROP(_)) | (DUP(_), DROP(_)) => - Some(Nil) - - case (BOX(t1), UNBOX(t2)) if (t1 == t2) => - Some(Nil) - - case (LOAD_FIELD(sym, isStatic), DROP(_)) => - if (isStatic) - Some(Nil) - else - Some(DROP(REFERENCE(definitions.ObjectClass)) :: Nil); - - case _ => None - }); - def analyzeClass(cls: IClass): Unit = if (settings.Xcloselim.value) { cls.methods.foreach { m => analyzeMethod(m) diff --git a/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala b/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala index a2b24fe0cb..4fb8067840 100644 --- a/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala +++ b/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala @@ -223,9 +223,9 @@ abstract class Inliners extends SubComponent { while (retry && count < MAX_INLINE_RETRY) m.normalize - } + } - private def isMonadicMethod(sym: Symbol) = sym.name match { + private def isMonadicMethod(sym: Symbol) = sym.name match { case nme.foreach | nme.filter | nme.map | nme.flatMap => true case _ => false } @@ -234,17 +234,17 @@ abstract class Inliners extends SubComponent { /** Should method 'sym' being called in 'receiver' be loaded from disk? */ def shouldLoadImplFor(sym: Symbol, receiver: Symbol): Boolean = { - if (settings.debug.value) - log("shouldLoadImplFor: " + receiver + "." + sym) - def alwaysLoad = (receiver.enclosingPackage == RuntimePackage) || (receiver == PredefModule.moduleClass) def loadCondition = sym.isEffectivelyFinal && isMonadicMethod(sym) && isHigherOrderMethod(sym) - hasInline(sym) || alwaysLoad || loadCondition + val res = hasInline(sym) || alwaysLoad || loadCondition + if (settings.debug.value) + log("shouldLoadImplFor: " + receiver + "." + sym + ": " + res) + res } - /** Look up implementation of method 'sym in 'clazz'. - */ + /** Look up implementation of method 'sym in 'clazz'. + */ def lookupImplFor(sym: Symbol, clazz: Symbol): Symbol = { // TODO: verify that clazz.superClass is equivalent here to clazz.tpe.parents(0).typeSymbol (.tpe vs .info) def needsLookup = (clazz != NoSymbol) && (clazz != sym.owner) && !sym.isEffectivelyFinal && clazz.isFinal |