Packages

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. def addCallsite(callsite: Callsite): Unit
  2. def addClass(classNode: ClassNode): Unit
  3. def addClosureInstantiation(closureInit: ClosureInstantiation): Unit
  4. def addIfMissing(methodNode: MethodNode, definingClass: ClassBType): Unit
  5. def addMethod(methodNode: MethodNode, definingClass: ClassBType): Unit
  6. 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.

  7. 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.

  8. def capturedSamTypes(lmf: LambdaMetaFactoryCall): IntMap[ClassBType]
  9. 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.

  10. def computeArgInfos(callee: Either[OptimizerWarning, Callee], callsiteInsn: MethodInsnNode, prodCons: ⇒ (backendUtils)#ProdConsAnalyzer): IntMap[ArgInfo]
  11. def computeCapturedArgInfos(lmf: LambdaMetaFactoryCall, prodCons: ⇒ (backendUtils)#ProdConsAnalyzer): IntMap[ArgInfo]
  12. def containsCallsite(callsite: Callsite): Boolean
  13. def findCallSite(method: MethodNode, call: MethodInsnNode): Option[Callsite]
  14. 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.

  15. val noInlineAnnotatedCallsites: Set[MethodInsnNode]
  16. def removeCallsite(invocation: MethodInsnNode, methodNode: MethodNode): Option[Callsite]
  17. def removeClosureInstantiation(indy: InvokeDynamicInsnNode, methodNode: MethodNode): Option[ClosureInstantiation]
  18. def samParamTypes(methodNode: MethodNode, receiverType: ClassBType): IntMap[ClassBType]
  19. object FunctionLiteral extends ArgInfo with Product with Serializable
  20. object LambdaMetaFactoryCall extends Serializable