Call graph with DCE

compiler/src/dotty/tools/backend/jvm/GenBCode.scala

@@ -201,7 +201,8 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
         val plainC = pcb.cnode
 
         if (claszSymbol.isClass) // @DarkDimius is this test needed here?
-          for (binary <- ctx.compilationUnit.pickled.get(claszSymbol.asClass)) {
+          for (pickler <- ctx.compilationUnit.picklers.get(claszSymbol.asClass)) {
+            val binary = pickler.assembleParts()
             val dataAttr = new CustomAttr(nme.TASTYATTR.mangledString, binary)
             val store = if (mirrorC ne null) mirrorC else plainC
             store.visitAttribute(dataAttr)

compiler/src/dotty/tools/dotc/CompilationUnit.scala

@@ -17,6 +17,12 @@ class CompilationUnit(val source: SourceFile) {
 
   def isJava = source.file.name.endsWith(".java")
 
-  /** Pickled TASTY binaries, indexed by class. */
-  var pickled: Map[ClassSymbol, Array[Byte]] = Map()
+  /**
+   * Picklers used to create TASTY sections, indexed by toplevel class to which they belong.
+   * Sections: Header, ASTs and Positions are populated by `pickler` phase.
+   * Subsequent phases can add new sections.
+   */
+  var picklers: Map[ClassSymbol, TastyPickler] = Map()
+
+  var unpicklers: Map[ClassSymbol, TastyUnpickler] = Map()
 }

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -13,6 +13,7 @@ import Phases.Phase
 import transform._
 import util.FreshNameCreator
 import transform.TreeTransforms.{TreeTransform, TreeTransformer}
+import transform.linker._
 import core.DenotTransformers.DenotTransformer
 import core.Denotations.SingleDenotation
 
@@ -47,6 +48,8 @@ class Compiler {
       List(new PostTyper),          // Additional checks and cleanups after type checking
       List(new sbt.ExtractAPI),     // Sends a representation of the API of classes to sbt via callbacks
       List(new Pickler),            // Generate TASTY info
+      List(new CollectSummaries),   // Collects method summaries for the call graph construction
+      List(new BuildCallGraph),     // Builds the call graph
       List(new FirstTransform,      // Some transformations to put trees into a canonical form
            new CheckReentrant,      // Internal use only: Check that compiled program has no data races involving global vars
            new ElimJavaPackages),   // Eliminate syntactic references to Java packages
@@ -69,6 +72,8 @@ class Compiler {
            new ShortcutImplicits,   // Allow implicit functions without creating closures
            new CrossCastAnd,        // Normalize selections involving intersection types.
            new Splitter),           // Expand selections involving union types into conditionals
+      List(new OuterSpecializer),
+      List(new OuterSpecializeParents),
       List(new VCInlineMethods,     // Inlines calls to value class methods
            new IsInstanceOfEvaluator, // Issues warnings when unreachable statements are present in match/if expressions
            new SeqLiterals,         // Express vararg arguments as arrays
@@ -82,7 +87,7 @@ class Compiler {
            new FunctionXXLForwarders, // Add forwarders for FunctionXXL apply method
            new ArrayConstructors),  // Intercept creation of (non-generic) arrays and intrinsify.
       List(new Erasure),            // Rewrite types to JVM model, erasing all type parameters, abstract types and refinements.
-      List(new ElimErasedValueType, // Expand erased value types to their underlying implmementation types
+      List(new ElimErasedValueType, // Expand erased value types to their underlying implementation types
            new VCElideAllocations,  // Peep-hole optimization to eliminate unnecessary value class allocations
            new Mixin,               // Expand trait fields and trait initializers
            new LazyVals,            // Expand lazy vals
@@ -94,6 +99,8 @@ class Compiler {
                                     // Note: constructors changes decls in transformTemplate, no InfoTransformers should be added after it
            new FunctionalInterfaces, // Rewrites closures to implement @specialized types of Functions.
            new GetClass,            // Rewrites getClass calls on primitive types.
+           new CallGraphChecks,
+           new DeadCodeElimination, // Replaces dead code by a `throw new DeadCodeEliminated`
            new Simplify),           // Perform local optimizations, simplified versions of what linker does.
       List(new LambdaLift,          // Lifts out nested functions to class scope, storing free variables in environments
                                        // Note: in this mini-phase block scopes are incorrect. No phases that rely on scopes should be here

compiler/src/dotty/tools/dotc/FromTasty.scala

@@ -15,7 +15,7 @@ import util._
 import reporting.Reporter
 import Decorators._
 import dotty.tools.dotc.transform.Pickler
-import tasty.DottyUnpickler
+import tasty.{DottyUnpickler, TastyBuffer}
 import ast.tpd._
 import NameKinds.QualifiedName
 
@@ -101,4 +101,13 @@ object FromTasty extends Driver {
         }
     }
   }
+
+  def compilationUnit(clsd: ClassDenotation, unpickler: DottyUnpickler)(implicit ctx: Context): CompilationUnit = {
+    val List(unpickled) = unpickler.body(ctx.addMode(Mode.ReadPositions))
+    val unit1 = new CompilationUnit(new SourceFile(clsd.symbol.sourceFile, Seq()))
+    unit1.tpdTree = unpickled
+    unit1.unpicklers += (clsd.classSymbol -> unpickler.unpickler)
+    force.traverse(unit1.tpdTree)
+    unit1
+  }
 }

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -43,6 +43,12 @@ class ScalaSettings extends Settings.SettingGroup {
   val rewrite = OptionSetting[Rewrites]("-rewrite", "When used in conjunction with -language:Scala2 rewrites sources to migrate to new syntax")
   val silentWarnings = BooleanSetting("-nowarn", "Silence all warnings.")
 
+  val linkDCE = BooleanSetting("-link-dce", "Enable dead code elimination.")
+  val linkDCEAggressive = BooleanSetting("-link-aggressive-dce", "Enable aggressive dead code elimination.")
+  val linkVis = BooleanSetting("-link-vis", "Output the visual representation of the call graph.")
+  val linkJavaConservative = BooleanSetting("-link-java-conservative", "Compute call graph for java methods.")
+  val linkSpecialize = BooleanSetting("-link-specialize", "Enable link time specialization.")
+
   /** -X "Advanced" settings
    */
   val Xhelp = BooleanSetting("-X", "Print a synopsis of advanced options.")
@@ -105,6 +111,9 @@ class ScalaSettings extends Settings.SettingGroup {
   val YnoDoubleBindings = BooleanSetting("-Yno-double-bindings", "Assert no namedtype is bound twice (should be enabled only if program is error-free).")
   val YshowVarBounds = BooleanSetting("-Yshow-var-bounds", "Print type variables with their bounds")
   val YnoInline = BooleanSetting("-Yno-inline", "Suppress inlining.")
+  val YlinkDCEChecks = BooleanSetting("-Ylink-dce-checks", "Check number of reachable classes and methods.")
+  val YlinkSpecialize = IntSetting("-YlinkSpecialize","Specialize methods with maximum this amount of polymorphic types.", 0, 0 to 10)
+
 
   /** Linker specific flags */
   val optimise = BooleanSetting("-optimise", "Generates faster bytecode by applying optimisations to the program") withAbbreviation "-optimize"

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -355,6 +355,8 @@ class Definitions {
   def DottyArraysModule(implicit ctx: Context) = DottyArraysModuleRef.symbol
     def newGenericArrayMethod(implicit ctx: Context) = DottyArraysModule.requiredMethod("newGenericArray")
     def newArrayMethod(implicit ctx: Context) = DottyArraysModule.requiredMethod("newArray")
+  def DottyArraysMethods(implicit ctx: Context) = List(newArrayMethod, newGenericArrayMethod)
+
 
   lazy val NilModuleRef = ctx.requiredModuleRef("scala.collection.immutable.Nil")
   def NilModule(implicit ctx: Context) = NilModuleRef.symbol
@@ -388,7 +390,7 @@ class Definitions {
     def ArrayConstructor(implicit ctx: Context) = ArrayConstructorR.symbol
   lazy val ArrayModuleType = ctx.requiredModuleRef("scala.Array")
   def ArrayModule(implicit ctx: Context) = ArrayModuleType.symbol.moduleClass.asClass
-
+  def ArrayMethods(implicit ctx: Context) = List(Array_apply, Array_update, Array_length, Array_clone, ArrayConstructor)
 
   lazy val UnitType: TypeRef = valueTypeRef("scala.Unit", BoxedUnitType, java.lang.Void.TYPE, UnitEnc)
   def UnitClass(implicit ctx: Context) = UnitType.symbol.asClass
@@ -458,6 +460,12 @@ class Definitions {
 
     def BoxedUnit_UNIT(implicit ctx: Context) = BoxedUnitClass.linkedClass.requiredValue("UNIT")
 
+
+  def isPrimitiveClass(sym: Symbol): Boolean = {
+    sym == defn.IntClass || sym == defn.LongClass || sym == defn.ShortClass || sym ==  defn.CharClass || sym == defn.ByteClass ||
+    sym == defn.BooleanClass || sym == defn.FloatClass || sym == defn.DoubleClass || sym == defn.UnitClass
+  }
+
   lazy val BoxedBooleanType: TypeRef = ctx.requiredClassRef("java.lang.Boolean")
   def BoxedBooleanClass(implicit ctx: Context) = BoxedBooleanType.symbol.asClass
   lazy val BoxedByteType: TypeRef = ctx.requiredClassRef("java.lang.Byte")
@@ -600,6 +608,8 @@ class Definitions {
   def ContravariantBetweenAnnot(implicit ctx: Context) = ContravariantBetweenAnnotType.symbol.asClass
   lazy val DeprecatedAnnotType = ctx.requiredClassRef("scala.deprecated")
   def DeprecatedAnnot(implicit ctx: Context) = DeprecatedAnnotType.symbol.asClass
+  lazy val EntryPointAnnotType = ctx.requiredClassRef("scala.EntryPoint")
+  def EntryPointAnnot(implicit ctx: Context) = EntryPointAnnotType.symbol.asClass
   lazy val ImplicitNotFoundAnnotType = ctx.requiredClassRef("scala.annotation.implicitNotFound")
   def ImplicitNotFoundAnnot(implicit ctx: Context) = ImplicitNotFoundAnnotType.symbol.asClass
   lazy val InlineAnnotType = ctx.requiredClassRef("scala.inline")

compiler/src/dotty/tools/dotc/core/NameKinds.scala

@@ -284,6 +284,8 @@ object NameKinds {
   val SkolemName              = new UniqueNameKind("?")
   val LiftedTreeName          = new UniqueNameKind("liftedTree")
   val SuperArgName            = new UniqueNameKind("$superArg$")
+  val SpecializedName         = new UniqueNameKind("$spec")
+  val DefaultExceptionName    = new UniqueNameKind(nme.DEFAULT_EXCEPTION_NAME.toString)
 
   /** A kind of unique extension methods; Unlike other unique names, these can be
    *  unmangled.

compiler/src/dotty/tools/dotc/core/Phases.scala

@@ -13,6 +13,7 @@ import config.Printers.config
 import scala.collection.mutable.{ListBuffer, ArrayBuffer}
 import dotty.tools.dotc.transform.TreeTransforms.{TreeTransformer, MiniPhase, TreeTransform}
 import dotty.tools.dotc.transform._
+import dotty.tools.dotc.transform.linker._
 import Periods._
 import typer.{FrontEnd, RefChecks}
 import ast.tpd
@@ -243,6 +244,7 @@ object Phases {
     private val explicitOuterCache = new PhaseCache(classOf[ExplicitOuter])
     private val gettersCache = new PhaseCache(classOf[Getters])
     private val genBCodeCache = new PhaseCache(classOf[GenBCode])
+    private val summariesCache = new PhaseCache(classOf[CollectSummaries])
 
     def typerPhase = typerCache.phase
     def picklerPhase = picklerCache.phase
@@ -257,6 +259,7 @@ object Phases {
     def explicitOuterPhase = explicitOuterCache.phase
     def gettersPhase = gettersCache.phase
     def genBCodePhase = genBCodeCache.phase
+    def summariesPhase = summariesCache.phase
 
     def isAfterTyper(phase: Phase): Boolean = phase.id > typerPhase.id
   }

compiler/src/dotty/tools/dotc/core/StdNames.scala

@@ -433,9 +433,9 @@ object StdNames {
     val info: N                 = "info"
     val inlinedEquals: N        = "inlinedEquals"
     val isArray: N              = "isArray"
+    val isDefined: N            = "isDefined"
     val isDefinedAt: N          = "isDefinedAt"
     val isDefinedAtImpl: N      = "$isDefinedAt"
-    val isDefined: N            = "isDefined"
     val isEmpty: N              = "isEmpty"
     val isInstanceOf_ : N       = "isInstanceOf"
     val java: N                 = "java"

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -18,6 +18,8 @@ import util.Stats
 import java.util.WeakHashMap
 import config.Config
 import config.Printers.{completions, incremental, noPrinter}
+import classfile.ClassfileParser
+import dotty.tools.dotc.core.tasty.DottyUnpickler
 
 trait SymDenotations { this: Context =>
   import SymDenotations._
@@ -1236,6 +1238,8 @@ object SymDenotations {
     initRunId: RunId)
     extends SymDenotation(symbol, ownerIfExists, name, initFlags, initInfo, initPrivateWithin) {
 
+    private[dotc] var dottyUnpickler: Option[DottyUnpickler] = None
+
     import util.LRUCache
 
     // ----- caches -------------------------------------------------------

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -1935,6 +1935,18 @@ object Types {
   class TermRefWithFixedSym(prefix: Type, name: TermName, val fixedSym: TermSymbol) extends TermRef(prefix, name) with WithFixedSym
   class TypeRefWithFixedSym(prefix: Type, name: TypeName, val fixedSym: TypeSymbol) extends TypeRef(prefix, name) with WithFixedSym
 
+  /* used by linker */
+  final class TypeRefWithFixedSymAndInfo(prefix: Type, name: TypeName, fixedSym: TypeSymbol, val underl: Type) extends TypeRefWithFixedSym(prefix, name, fixedSym) {
+    override def derivedSelect(prefix: Type)(implicit ctx: Context): Type = {
+      assert(prefix eq this.prefix, "loss in precision")
+      this
+    }
+
+    override def info(implicit ctx: Context): Type = underl
+
+    override def equals(that: Any): Boolean = that.isInstanceOf[TypeRefWithFixedSymAndInfo] && super.equals(that) && this.underl == that.asInstanceOf[TypeRefWithFixedSymAndInfo].underl
+  }
+
   /** Assert current phase does not have erasure semantics */
   private def assertUnerased()(implicit ctx: Context) =
     if (Config.checkUnerased) assert(!ctx.phase.erasedTypes)
@@ -2045,6 +2057,10 @@ object Types {
      */
     def withFixedSym(prefix: Type, name: TypeName, sym: TypeSymbol)(implicit ctx: Context): TypeRef =
       unique(new TypeRefWithFixedSym(prefix, name, sym))
+
+     def withFixedSymAndInfo(prefix: Type, name: TypeName, sym: TypeSymbol, info: Type)(implicit ctx: Context): TypeRef = {
+      unique(new TypeRefWithFixedSymAndInfo(prefix, name, sym, info))
+    }
 
     /** Create a type ref referring to given symbol with given name.
      *  This is very similar to TypeRef(Type, Symbol),
@@ -3440,22 +3456,28 @@ object Types {
   // ----- Annotated and Import types -----------------------------------------------
 
   /** An annotated type tpe @ annot */
-  case class AnnotatedType(tpe: Type, annot: Annotation)
-      extends UncachedProxyType with ValueType {
+  abstract case class AnnotatedType(tpe: Type, annot: Annotation)
+      extends CachedProxyType with ValueType {
     // todo: cache them? but this makes only sense if annotations and trees are also cached.
     override def underlying(implicit ctx: Context): Type = tpe
-    def derivedAnnotatedType(tpe: Type, annot: Annotation) =
+    def derivedAnnotatedType(tpe: Type, annot: Annotation)(implicit ctx: Context) =
       if ((tpe eq this.tpe) && (annot eq this.annot)) this
       else AnnotatedType(tpe, annot)
 
     override def stripTypeVar(implicit ctx: Context): Type =
       derivedAnnotatedType(tpe.stripTypeVar, annot)
     override def stripAnnots(implicit ctx: Context): Type = tpe.stripAnnots
+
+    override def computeHash: Int = doHash(annot, tpe)
   }
 
+  class CachedAnnotatedType(tpe: Type, annot: Annotation) extends AnnotatedType(tpe, annot)
+
   object AnnotatedType {
-    def make(underlying: Type, annots: List[Annotation]) =
-      (underlying /: annots)(AnnotatedType(_, _))
+    def apply(tpe: Type, annot: Annotation)(implicit ctx: Context) =
+      unique(new CachedAnnotatedType(tpe, annot))
+    def make(underlying: Type, annots: List[Annotation])(implicit ctx: Context) =
+      (underlying /: annots)(apply(_, _))
   }
 
   // Special type objects and classes -----------------------------------------------------

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -6,6 +6,7 @@ package classfile
 import Contexts._, Symbols._, Types._, Names._, StdNames._, NameOps._, Scopes._, Decorators._
 import SymDenotations._, unpickleScala2.Scala2Unpickler._, Constants._, Annotations._, util.Positions._
 import NameKinds.{ModuleClassName, DefaultGetterName}
+import tasty.DottyUnpickler
 import ast.tpd._
 import java.io.{ ByteArrayInputStream, DataInputStream, File, IOException }
 import java.lang.Integer.toHexString
@@ -145,6 +146,13 @@ class ClassfileParser(
       setClassInfo(moduleRoot, staticInfo)
     }
 
+    result match {
+      case result @ Some(_: DottyUnpickler) =>
+        classRoot.dottyUnpickler = result.asInstanceOf[Option[DottyUnpickler]]
+        moduleRoot.dottyUnpickler = result.asInstanceOf[Option[DottyUnpickler]]
+      case _ =>
+    }
+
     // eager load java enum definitions for exhaustivity check of pattern match
     if (isEnum) {
       instanceScope.toList.map(_.ensureCompleted())

compiler/src/dotty/tools/dotc/core/tasty/DottyUnpickler.scala

@@ -11,6 +11,9 @@ import util.{SourceFile, NoSource}
 import Annotations.Annotation
 import core.Mode
 import classfile.ClassfileParser
+import dotty.tools.dotc.transform.linker.summaries.MethodSummary
+import dotty.tools.dotc.transform.linker.summaries.TastySummaries
+import scala.collection.mutable
 
 object DottyUnpickler {
 
@@ -27,6 +30,13 @@ object DottyUnpickler {
     def unpickle(reader: TastyReader, nameAtRef: NameTable) =
       new PositionUnpickler(reader)
   }
+
+  class SummariesTreeSectionUnpickler(symAtAddr: mutable.HashMap[Addr, Symbol], sectionName: String)
+      extends TreeSectionUnpickler(posUnpickler = None) {
+    override def unpickle(reader: TastyReader, tastyName: NameTable): SummariesTreeUnpickler = {
+      new SummariesTreeUnpickler(symAtAddr, reader, tastyName, sectionName)
+    }
+  }
 }
 
 /** A class for unpickling Tasty trees and symbols.
@@ -57,4 +67,20 @@ class DottyUnpickler(bytes: Array[Byte]) extends ClassfileParser.Embedded {
       myBody
     } else computeBody()
   }
+
+  def summaries(implicit ctx: Context): List[MethodSummary] = {
+    val sectionName = TastySummaries.sectionName
+    val tastySection = unpickler.unpickle(new SummariesTreeSectionUnpickler(treeUnpickler.symAtAddr, sectionName)).get
+    tastySection.asInstanceOf[SummariesTreeUnpickler].getStartReader(ctx) match {
+      case Some(treeReader) =>
+        val unp = new TastyUnpickler.SectionUnpickler[List[MethodSummary]](sectionName) {
+          def unpickle(reader: TastyReader, tastyName: NameTable): List[MethodSummary] =
+            new TastySummaries.SummaryReader(treeReader, reader)(ctx).read()
+        }
+        unpickler.unpickle(unp).getOrElse(Nil)
+
+      case None => Nil
+    }
+
+  }
 }

compiler/src/dotty/tools/dotc/core/tasty/SummariesTreeUnpickler.scala

@@ -0,0 +1,34 @@
+package dotty.tools.dotc.core.tasty
+
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Mode
+import dotty.tools.dotc.core.Names.TermName
+import dotty.tools.dotc.core.tasty.TastyBuffer.{Addr, NameRef}
+
+import scala.collection.mutable
+
+class SummariesTreeUnpickler(override val symAtAddr: mutable.HashMap[Addr, Symbol], reader: TastyReader, tastyName: NameRef => TermName, sectionName: String)
+    extends TreeUnpickler(reader, tastyName, posUnpicklerOpt = None) {
+
+  roots = Set.empty
+
+  def getStartReader(implicit ctx: Context): Option[TreeReader] = {
+    val st = new TreeReader(reader)
+    st.skipToplevel()(ctx.addMode(Mode.AllowDependentFunctions))
+
+    while (true) {
+      while (reader.nextByte != TastyFormat.VALDEF && !reader.isAtEnd) st.skipTree()
+      if (reader.isAtEnd) return None // no section here
+      val tag = reader.readByte()
+      val end = reader.readEnd()
+      val name = st.readName()
+      if (name.toString == sectionName) return Some(st.forkAt(end))
+      st.skipTree() // skip type
+      st.skipTree() // skip rhs
+    }
+
+    None
+  }
+
+}

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -153,6 +153,11 @@ class TreePickler(pickler: TastyPickler) {
           writeByte(if (tpe.isType) TYPEREFdirect else TERMREFdirect)
           pickleSymRef(sym)
         }
+        else if (tpe.isTerm) {
+          writeByte(TERMREF) // should be changed to a new entry that keeps track of prefix, symbol & owner
+          pickleName(tpe.name)
+          pickleType(tpe.prefix)
+        }
         else {
           assert(tpe.symbol.isClass)
           assert(tpe.symbol.is(Flags.Scala2x), tpe.symbol.showLocated)