Scala Compiler2.12.16 < Back
 

# Packages

-  package root

  The Scala compiler and reflection APIs.

  The Scala compiler and reflection APIs.

  Definition Classes
    root
-  package scala
  Definition Classes
    root
-  package tools
  Definition Classes
    scala
-  package nsc
  Definition Classes
    tools
-  package backend
  Definition Classes
    nsc
-  package jvm
  Definition Classes
    backend
-  package opt
  Definition Classes
    jvm
- BoxUnbox
- ByteCodeRepository
- BytecodeUtils
- CallGraph
- ClosureOptimizer
- CopyProp
- InlineInfoAttribute
- InlineInfoAttributePrototype
- Inliner
- InlinerHeuristics
- LabelNotLive
- LocalOpt
- LocalOptImpls
- LruMap
- RemovePair
- RemovePairDependency

c

scala.tools.nsc.backend.jvm.opt

# CallGraph 

###

#### abstract class CallGraph extends AnyRef

Source
  CallGraph.scala

Linear Supertypes
AnyRef, Any
 
Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. CallGraph
2. AnyRef
3. Any

Implicitly

1. by any2stringadd
2. by StringFormat
3. by Ensuring
4. by ArrowAssoc

1. Hide All
2. Show All

Visibility

1. Public
2. All

### Instance Constructors

1.  new CallGraph()

### Type Members

1.  sealed trait ArgInfo extends AnyRef

   Information about invocation arguments, obtained through data flow analysis of the callsite method.

2.  final case class Callee(callee: MethodNode, calleeDeclarationClass: ClassBType, isStaticallyResolved: Boolean, sourceFilePath: Option[String], annotatedInline: Boolean, annotatedNoInline: Boolean, samParamTypes: IntMap[ClassBType], calleeInfoWarning: Option[CalleeInfoWarning]) extends Product with Serializable

   A callee in the call graph.

   A callee in the call graph.

   callee

     The callee, as it appears in the invocation instruction. For virtual calls, an override of the callee might be invoked. Also, the callee can be abstract.

   calleeDeclarationClass

     The class in which the callee is declared

   isStaticallyResolved

     True if the callee cannot be overridden

   annotatedInline

     True if the callee is annotated @inline

   annotatedNoInline

     True if the callee is annotated @noinline

   samParamTypes

     A map from parameter positions to SAM parameter types

   calleeInfoWarning

     An inliner warning if some information was not available while gathering the information about this callee.

3.  final case class Callsite(callsiteInstruction: MethodInsnNode, callsiteMethod: MethodNode, callsiteClass: ClassBType, callee: Either[OptimizerWarning, Callee], argInfos: IntMap[ArgInfo], callsiteStackHeight: Int, receiverKnownNotNull: Boolean, callsitePosition: Position, annotatedInline: Boolean, annotatedNoInline: Boolean) extends Product with Serializable

   A callsite in the call graph.

   A callsite in the call graph.

   callsiteInstruction

     The invocation instruction

   callsiteMethod

     The method containing the callsite

   callsiteClass

     The class containing the callsite

   callee

     The callee, as it appears in the invocation instruction. For virtual calls, an override of the callee might be invoked. Also, the callee can be abstract. Contains a warning message if the callee MethodNode cannot be found in the bytecode repository.

   argInfos

     Information about the invocation receiver and arguments

   callsiteStackHeight

     The stack height at the callsite, required by the inliner

   callsitePosition

     The source position of the callsite, used for inliner warnings.

4.  final case class ClonedCallsite(callsite: Callsite, clonedWhenInlining: Callsite) extends Product with Serializable
5.  final case class ClosureInstantiation(lambdaMetaFactoryCall: LambdaMetaFactoryCall, ownerMethod: MethodNode, ownerClass: ClassBType, capturedArgInfos: IntMap[ArgInfo]) extends Product with Serializable

   Metadata about a closure instantiation, stored in the call graph

   Metadata about a closure instantiation, stored in the call graph

   lambdaMetaFactoryCall

     the InvokeDynamic instruction

   ownerMethod

     the method where the closure is allocated

   ownerClass

     the class containing the above method

   capturedArgInfos

     information about captured arguments. Used for updating the call graph when re-writing a closure invocation to the body method.

6.  final case class ForwardedParam(index: Int) extends ArgInfo with Product with Serializable
7.  final case class LambdaMetaFactoryCall(indy: InvokeDynamicInsnNode, samMethodType: Type, implMethod: Handle, instantiatedMethodType: Type) extends Product with Serializable

### Abstract Value Members

1.  abstract val postProcessor: PostProcessor

### Concrete Value Members

1.  final def !=(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
2.  final def ##(): Int
   Definition Classes
     AnyRef → Any
3.  def +(other: String): String
   Implicit
     This member is added by an implicit conversion from CallGraph to any2stringadd[CallGraph] performed by method any2stringadd in scala.Predef.
   Definition Classes
     any2stringadd
4.  def ->[B](y: B): (CallGraph, B)
   Implicit
     This member is added by an implicit conversion from CallGraph to ArrowAssoc[CallGraph] performed by method ArrowAssoc in scala.Predef.
   Definition Classes
     ArrowAssoc
   Annotations
     @inline()
5.  final def ==(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
6.  def addCallsite(callsite: Callsite): Unit
7.  def addClass(classNode: ClassNode): Unit
8.  def addClosureInstantiation(closureInit: ClosureInstantiation): Unit
9.  def addIfMissing(methodNode: MethodNode, definingClass: ClassBType): Unit
10.  def addMethod(methodNode: MethodNode, definingClass: ClassBType): Unit
11.  final def asInstanceOf[T0]: T0
    Definition Classes
      Any
12.  val callsitePositions: Map[MethodInsnNode, Position]

    Store the position of every MethodInsnNode during code generation.

    Store the position of every MethodInsnNode during code generation. This allows each callsite in the call graph to remember its source position, which is required for inliner warnings.

13.  val callsites: Map[MethodNode, Map[MethodInsnNode, Callsite]]

    The call graph contains the callsites in the program being compiled.

    The call graph contains the callsites in the program being compiled.

    Indexing the call graph by the containing MethodNode and the invocation MethodInsnNode allows finding callsites efficiently. For example, an inlining heuristic might want to know all callsites within a callee method.

    Note that the call graph is not guaranteed to be complete: callsites may be missing. In particular, if a method is very large, all of its callsites might not be in the hash map. The reason is that adding a method to the call graph requires running an ASM analyzer, which can be too slow.

    Note that call graph entries (Callsite instances) keep a reference to the invocation MethodInsnNode, which keeps all AbstractInsnNodes of the method reachable. Adding classes from the classpath to the call graph (in addition to classes being compiled) may prevent method instruction nodes from being GCd. The ByteCodeRepository has a fixed size cache for parsed ClassNodes - keeping all ClassNodes alive consumed too much memory. The call graph is less problematic because only methods being called are kept alive, not entire classes. But we should keep an eye on this.

14.  def capturedSamTypes(lmf: LambdaMetaFactoryCall): IntMap[ClassBType]
15.  def clone(): AnyRef
    Attributes
      protected[lang]
    Definition Classes
      AnyRef
    Annotations
      @throws( ... ) @native()
16.  val closureInstantiations: Map[MethodNode, Map[InvokeDynamicInsnNode, ClosureInstantiation]]

    Closure instantiations in the program being compiled.

    Closure instantiations in the program being compiled.

    Indexing closure instantiations by the containing MethodNode is beneficial for the closure optimizer: finding callsites to re-write requires running a producers-consumers analysis on the method. Here the closure instantiations are already grouped by method.

17.  def computeArgInfos(callee: Either[OptimizerWarning, Callee], callsiteInsn: MethodInsnNode, prodCons: ⇒ (backendUtils)#ProdConsAnalyzer): IntMap[ArgInfo]
18.  def computeCapturedArgInfos(lmf: LambdaMetaFactoryCall, prodCons: ⇒ (backendUtils)#ProdConsAnalyzer): IntMap[ArgInfo]
19.  def containsCallsite(callsite: Callsite): Boolean
20.  def ensuring(cond: (CallGraph) ⇒ Boolean, msg: ⇒ Any): CallGraph
    Implicit
      This member is added by an implicit conversion from CallGraph to Ensuring[CallGraph] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
21.  def ensuring(cond: (CallGraph) ⇒ Boolean): CallGraph
    Implicit
      This member is added by an implicit conversion from CallGraph to Ensuring[CallGraph] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
22.  def ensuring(cond: Boolean, msg: ⇒ Any): CallGraph
    Implicit
      This member is added by an implicit conversion from CallGraph to Ensuring[CallGraph] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
23.  def ensuring(cond: Boolean): CallGraph
    Implicit
      This member is added by an implicit conversion from CallGraph to Ensuring[CallGraph] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
24.  final def eq(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef
25.  def equals(arg0: Any): Boolean
    Definition Classes
      AnyRef → Any
26.  def finalize(): Unit
    Attributes
      protected[lang]
    Definition Classes
      AnyRef
    Annotations
      @throws( classOf[java.lang.Throwable] )
27.  def findCallSite(method: MethodNode, call: MethodInsnNode): Option[Callsite]
28.  final def getClass(): Class[_]
    Definition Classes
      AnyRef → Any
    Annotations
      @native()
29.  def hashCode(): Int
    Definition Classes
      AnyRef → Any
    Annotations
      @native()
30.  val inlineAnnotatedCallsites: Set[MethodInsnNode]

    Stores callsite instructions of invocations annotated `f(): @inline/noinline`.

    Stores callsite instructions of invocations annotated `f(): @inline/noinline`. Instructions are added during code generation (BCodeBodyBuilder). The maps are then queried when building the CallGraph, every Callsite object has an annotated(No)Inline field.

31.  final def isInstanceOf[T0]: Boolean
    Definition Classes
      Any
32.  final def ne(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef
33.  val noInlineAnnotatedCallsites: Set[MethodInsnNode]
34.  final def notify(): Unit
    Definition Classes
      AnyRef
    Annotations
      @native()
35.  final def notifyAll(): Unit
    Definition Classes
      AnyRef
    Annotations
      @native()
36.  def removeCallsite(invocation: MethodInsnNode, methodNode: MethodNode): Option[Callsite]
37.  def removeClosureInstantiation(indy: InvokeDynamicInsnNode, methodNode: MethodNode): Option[ClosureInstantiation]
38.  def samParamTypes(methodNode: MethodNode, receiverType: ClassBType): IntMap[ClassBType]
39.  final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
      AnyRef
40.  def toString(): String
    Definition Classes
      AnyRef → Any
41.  final def wait(): Unit
    Definition Classes
      AnyRef
    Annotations
      @throws( ... )
42.  final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
      AnyRef
    Annotations
      @throws( ... )
43.  final def wait(arg0: Long): Unit
    Definition Classes
      AnyRef
    Annotations
      @throws( ... ) @native()
44.  def →[B](y: B): (CallGraph, B)
    Implicit
      This member is added by an implicit conversion from CallGraph to ArrowAssoc[CallGraph] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
      ArrowAssoc
45.  object FunctionLiteral extends ArgInfo with Product with Serializable
46.  object LambdaMetaFactoryCall extends Serializable

### Deprecated Value Members

1.  def formatted(fmtstr: String): String
   Implicit
     This member is added by an implicit conversion from CallGraph to StringFormat[CallGraph] performed by method StringFormat in scala.Predef.
   Definition Classes
     StringFormat
   Annotations
     @deprecated @inline()
   Deprecated

     (Since version 2.12.16) Use `formatString.format(value)` instead of `value.formatted(formatString)`, or use the `f""` string interpolator. In Java 15 and later, `formatted` resolves to the new method in String which has reversed parameters.

### Inherited from AnyRef

### Inherited from Any

### Inherited by implicit conversion any2stringadd from CallGraph to any2stringadd[CallGraph]

### Inherited by implicit conversion StringFormat from CallGraph to StringFormat[CallGraph]

### Inherited by implicit conversion Ensuring from CallGraph to Ensuring[CallGraph]

### Inherited by implicit conversion ArrowAssoc from CallGraph to ArrowAssoc[CallGraph]

### Ungrouped