Packages

  • package root
    Definition Classes
    root
  • package org
    Definition Classes
    root
  • package opalj

    OPAL is a Scala-based framework for the static analysis, manipulation and creation of Java bytecode.

    OPAL is a Scala-based framework for the static analysis, manipulation and creation of Java bytecode. OPAL is designed with performance, scalability and adaptability in mind.

    Its main components are:

    • a library (Common) which provides generally useful data-structures and algorithms for static analyses.
    • a framework for implementing lattice based static analyses (Static Analysis Infrastructure)
    • a framework for parsing Java bytecode (Bytecode Infrastructure) that can be used to create arbitrary representations.
    • a library to create a one-to-one in-memory representation of Java bytecode (Bytecode Disassembler).
    • a library to create a representation of Java bytecode that facilitates writing simple static analyses (Bytecode Representation - org.opalj.br).
    • a scalable, easily customizable framework for the abstract interpretation of Java bytecode (Abstract Interpretation Framework - org.opalj.ai).
    • a library to extract dependencies between code elements and to facilitate checking architecture definitions.
    • a library for the lightweight manipulation and creation of Java bytecode (Bytecode Assembler).

    General Design Decisions

    Thread Safety

    Unless explicitly noted, OPAL is thread safe. I.e., the classes defined by OPAL can be considered to be thread safe unless otherwise stated. (For example, it is possible to read and process class files concurrently without explicit synchronization on the client side.)

    No null Values

    Unless explicitly noted, OPAL does not null values I.e., fields that are accessible will never contain null values and methods will never return null. If a method accepts null as a value for a parameter or returns a null value it is always explicitly documented. In general, the behavior of methods that are passed null values is undefined unless explicitly documented.

    No Typecasts for Collections

    For efficiency reasons, OPAL sometimes uses mutable data-structures internally. After construction time, these data-structures are generally represented using their generic interfaces (e.g., scala.collection.{Set,Map}). However, a downcast (e.g., to add/remove elements) is always forbidden as it would effectively prevent thread-safety.

    Assertions

    OPAL makes heavy use of Scala's Assertion Facility to facilitate writing correct code. Hence, for production builds (after thorough testing(!)) it is highly recommend to build OPAL again using -Xdisable-assertions.

    Definition Classes
    org
  • package br

    In this representation of Java bytecode references to a Java class file's constant pool and to attributes are replaced by direct references to the corresponding constant pool entries.

    In this representation of Java bytecode references to a Java class file's constant pool and to attributes are replaced by direct references to the corresponding constant pool entries. This facilitates developing analyses and fosters comprehension.

    Based on the fact that indirect references to constant pool entries are resolved and replaced by direct references this representation is called the resolved representation.

    This representation of Java bytecode is considered as OPAL's standard representation for writing Scala based analyses. This representation is engineered such that it facilitates writing analyses that use pattern matching.

    Definition Classes
    opalj
  • package analyses

    Defines commonly useful type aliases.

    Defines commonly useful type aliases.

    Definition Classes
    br
  • package cg
  • Analysis
  • AnalysisApplication
  • AnalysisException
  • BasicMethodInfo
  • BasicReport
  • DeclaredMethods
  • DeclaredMethodsKey
  • FieldAccessInformation
  • FieldAccessInformationAnalysis
  • FieldAccessInformationKey
  • InconsistentProjectException
  • JavaProject
  • MethodAnalysisApplication
  • MethodDeclarationContext
  • MethodDeclarationContextOrdering
  • MethodInfo
  • ModuleDefinition
  • OneStepAnalysis
  • ProgressEvents
  • ProgressManagement
  • Project
  • ProjectAnalysisApplication
  • ProjectBasedAnalysis
  • ProjectIndex
  • ProjectIndexKey
  • ProjectInformationKey
  • ProjectLike
  • ReportableAnalysisResult
  • StringConstantsInformationKey
  • VirtualFormalParameter
  • VirtualFormalParameters
  • VirtualFormalParametersKey
  • package cfg
    Definition Classes
    br
  • package collection
    Definition Classes
    br
  • package cp

    Implementation of classes to represent/recreate a class file's constant pool.

    Implementation of classes to represent/recreate a class file's constant pool.

    Definition Classes
    br
  • package fpcf
    Definition Classes
    br
  • package instructions

    Common instruction sequences.

    Common instruction sequences.

    Definition Classes
    br
  • package reader

    Defines convenience methods related to reading in class files.

    Defines convenience methods related to reading in class files.

    Definition Classes
    br
p

org.opalj.br

analyses

package analyses

Defines commonly useful type aliases.

Source
package.scala
Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. analyses
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. trait Analysis[Source, +AnalysisResult] extends AnyRef

    Common trait that analyses can inherit from when they want to use the general analysis framework AnalysisApplication.

    Common trait that analyses can inherit from when they want to use the general analysis framework AnalysisApplication.

    Conceptual Idea

    An analysis is basically a mapping of a Project's resources to some result.

    Each analysis can produce (optionally) some result. E.g., a text describing a scenario that leads to a bug, a graph, a report that identifies a specific line or a combination thereof.

    However, an analysis should never rely on the location of a resource. If an analysis needs access to further resources, it should use the Project class.

  2. trait AnalysisApplication extends AnyRef

    Provides the necessary infrastructure to easily execute a given analysis that generates some analysis result that can be printed on the command line.

    Provides the necessary infrastructure to easily execute a given analysis that generates some analysis result that can be printed on the command line.

    To facilitate the usage of this trait several implicit conversions are defined that wrap standard analyses (org.opalj.br.analyses) such that they report results that are reportable.

    This class distinguishes between class files belonging to the code base under analysis and those that belong to the libraries. Those belonging to the libraries are loaded using the ClassFileReader for library classes (basically, all method bodies are skipped org.opalj.br.reader.Java8LibraryFramework). The parameter to specify library classes is -libcp=, the parameter to specify the "normal" classpath is -cp=.

    Control Flow

    1. The standard parameters are checked.
    2. The analysis is called to let it verify the analysis specific parameters.
    3. The Project is created.
    4. The analyze method of the Analysis is called with the project and the parameters.
    5. The results are printed.
  3. case class AnalysisException(message: String, cause: Throwable = null) extends RuntimeException with Product with Serializable

    Exception raised while the analysis is executed.

  4. case class BasicReport(toConsoleString: String) extends ReportableAnalysisResult with Product with Serializable

    Result of some analysis that just consists of some text.

    Result of some analysis that just consists of some text.

    toConsoleString

    A string printed to the console.

  5. class DeclaredMethods extends AnyRef

    The set of all org.opalj.br.DeclaredMethods (potentially used by the property store).

  6. class FieldAccessInformation extends AnyRef

    Stores the information where each field is read and written.

    Stores the information where each field is read and written. If the project is incomplete the results are also necessarily incomplete. Reflective and comparable accesses are not considered.

  7. case class InconsistentProjectException(message: String, severity: Level = Warn) extends Exception with Product with Serializable

    Thrown when the framework determines that the project is not consistent.

  8. class JavaProject extends AnyRef

    Enables the querying of a project.

    Enables the querying of a project.

    Note

    The interface of this class was designed with Java interoperability in mind!

  9. abstract class MethodAnalysisApplication extends ProjectAnalysisApplication

    A small framework to implement analyses which should be executed for a given set of methods.

  10. final class MethodDeclarationContext extends Ordered[MethodDeclarationContext]

    Encapsulates the information about a non-abstract, non-static method which is not an initializer (<(cl)init>) and which is required when determining potential call targets.

    Encapsulates the information about a non-abstract, non-static method which is not an initializer (<(cl)init>) and which is required when determining potential call targets.

    Note

    A class may have -- w.r.t. a given package name -- at most one package visible method which has a specific name and descriptor combination. For methods with protected or public visibility a class always has at most one method with a given name and descriptor.

    ,

    Equality is defined based on the name, descriptor and declaring package of a method (the concrete declaring class is not considered!).

  11. case class MethodInfo[Source](source: Source, method: Method) extends Product with Serializable

    Encapsulates the source of a method.

  12. case class ModuleDefinition[Source](module: ClassFile, source: Option[Source]) extends Product with Serializable
  13. type MultipleResultsAnalysis[Source, +AnalysisResult] = Analysis[Source, Iterable[AnalysisResult]]

    An analysis that may produce multiple results.

    An analysis that may produce multiple results. E.g., an analysis that looks for instances of bug patterns.

  14. trait OneStepAnalysis[Source, +AnalysisResult] extends Analysis[Source, AnalysisResult]

    An analysis that performs all computations in one step.

    An analysis that performs all computations in one step. Only very short-running analyses should use this interface as reporting progress is not supported.

  15. type ProgressEvent = analyses.ProgressEvents.Value
  16. trait ProgressManagement extends AnyRef

    Enables the management of the progress of a long running computation.

    Enables the management of the progress of a long running computation. Typically a long running progress, such as an analysis, is expected to report progress every 250 to 2000 milliseconds. It should -- however -- check every ~100 milliseconds the interrupted status to enable a timely termination.

    This trait defines a call-back interface that is implemented by some class that runs an analysis and which passes an instance of it to some analysis to report progress.

    Note

    Implementations of this class must be thread safe if the analysis is multi- threaded.

    ,

    Implementations must handle the case where a step that was started later finishes earlier than a previous step. In other words, even if the last step has ended, that does not mean that the analysis as a whole has already finished. Instead an implementation has to track how many steps have ended to determine when the whole analysis has ended.

  17. class Project[Source] extends ProjectLike

    Primary abstraction of a Java project; i.e., a set of classes that constitute a library, framework or application as well as the libraries or frameworks used by the former.

    Primary abstraction of a Java project; i.e., a set of classes that constitute a library, framework or application as well as the libraries or frameworks used by the former.

    This class has several purposes:

    1. It is a container for ClassFiles.
    2. It directly gives access to the project's class hierarchy.
    3. It serves as a container for project-wide information (e.g., a call graph, information about the mutability of classes, constant values,...) that can be queried using org.opalj.br.analyses.ProjectInformationKeys. The list of project wide information that can be made available is equivalent to the list of (concrete/singleton) objects implementing the trait org.opalj.br.analyses.ProjectInformationKey. One of the most important project information keys is the PropertyStoreKey which gives access to the property store.

    Thread Safety

    This class is thread-safe.

    Prototyping Analyses/Querying Projects

    Projects can easily be created and queried using the Scala REPL. For example, to create a project, you can use:

    val project = org.opalj.br.analyses.Project(org.opalj.bytecode.JRELibraryFolder)

    Now, to determine the number of methods that have at least one parameter of type int, you can use:

    project.methods.filter(_.parameterTypes.exists(_.isIntegerType)).size
    Source

    The type of the source of the class file. E.g., a URL, a File, a String or a Pair (JarFile,JarEntry). This information is needed for, e.g., presenting users meaningful messages w.r.t. the location of issues. We abstract over the type of the resource to facilitate the embedding in existing tools such as IDEs. E.g., in Eclipse IResource's are used to identify the location of a resource (e.g., a source or class file.)

  18. abstract class ProjectAnalysisApplication extends AnalysisApplication with OneStepAnalysis[URL, ReportableAnalysisResult]

    Default implementation of the AnalysisApplication trait which facilitates the development of analyses which are executed in one step.

  19. trait ProjectBasedAnalysis extends AnyRef

    Common super trait of all analyses that use the fixpoint computations framework.

    Common super trait of all analyses that use the fixpoint computations framework. In general, an analysis computes a org.opalj.fpcf.Property by processing some entities, e.g.: ´classes´, ´methods´ or ´fields´.

  20. class ProjectIndex extends AnyRef

    An index that enables the efficient lookup of source elements (methods and fields) given the method's/field's name and the descriptor/field type.

    An index that enables the efficient lookup of source elements (methods and fields) given the method's/field's name and the descriptor/field type. The index contains fields with public, protected, <default> and private visibility.

    Basically an index of the source elements (methods and fields) of a project.

    This index can be used, e.g., to resolve method calls based on the method's names and/or descriptors.

    To get an instance of a project index call Project.get and pass in the ProjectIndexKey object.

    See also

    FieldAccessInformation to get the information where a field is accessed.

  21. trait ProjectInformationKey[T <: AnyRef, I <: AnyRef] extends AnyRef

    ProjectInformationKey objects are used to get/associate some (immutable) information with a project that should be computed on demand.

    ProjectInformationKey objects are used to get/associate some (immutable) information with a project that should be computed on demand. For example, imagine that you write an analysis that requires – as a foundation – the project's call graph. In this case, to get the call graph it is sufficient to pass the respective key to the Project object. If the call graph was already computed that one will be returned, otherwise the computation will be performed and the result will be cached for future usage before it is returned.

    Using Project Information

    If access to some project information is required, it is sufficient to use the (singleton) instance of the respective ProjectInformationKey to get the respective project information.

    For example, let's assume that an index of all fields and methods is needed. In this case the code to get the index would be:

    import ...{ProjectIndex,ProjectIndexKey}
    val project : Project = ???
    val projectIndex = project.get(ProjectIndexKey)
    // do something with the index

    Providing Project Information/Implementing ProjectInformationKey

    Making project wide information available on demand is done as follows.

    1. Implement the base analysis that computes the information given some project.
    2. Implement your ProjectInformationKey class that inherits from this trait and which calls the base analysis. It is recommended that the factory method (compute) is side-effect free.
    Threading

    Project takes care of threading related issues. The methods requirements and compute will never be called concurrently w.r.t. the same project object. However, concurrent calls may happen w.r.t. two different project objects.

    Caching

    Project takes care of the caching of the result of the computation of the information.

    T

    The type of the information object that is derived.

    I

    The type of information used at initialization time.

  22. type ProjectInformationKeys = Seq[ProjectInformationKey[_ <: AnyRef, _ <: AnyRef]]
  23. abstract class ProjectLike extends ClassFileRepository

    Enables project wide lookups of methods and fields as required to determine the target(s) of an invoke or field access instruction.

    Enables project wide lookups of methods and fields as required to determine the target(s) of an invoke or field access instruction.

    Note

    The current implementation is based on the correct project assumption; i.e., if the bytecode of the project as a whole is not valid, the result is generally undefined. Just one example of a violation of the assumption would be, if we have two interfaces which define a non-abstract method with the same signature and both interfaces are implemented by a third interface which does not override these methods. In this case the result of a resolveMethodReference is not defined, because the code base as a whole is not valid.

  24. trait ReportableAnalysisResult extends AnyRef

    Result of analyses that can be meaningfully represented using text.

  25. type SingleOptionalResultAnalysis[Source, +AnalysisResult] = Analysis[Source, Option[AnalysisResult]]

    An analysis that may produce a result.

  26. type SomeProject = Project[_]

    Type alias for Project's with an arbitrary sources.

  27. type StringConstantsInformation = Map[String, ConstArray[PCInMethod]]
  28. final class VirtualFormalParameter extends AnyRef

    Explicitly models a formal parameter of a DeclaredMethod to make it possible to store it in the property store and to compute properties for it.

    Explicitly models a formal parameter of a DeclaredMethod to make it possible to store it in the property store and to compute properties for it.

    The first parameter explicitly defined by the method will have the origin -2, the second one will have the origin -3 and so on. That is, the origin of an explicitly declared parameter is always -(parameter_index + 2). The origin of the this parameter is -1.

    Note

    The computational type category of the parameters is ignored to ease the mapping.

    ,

    This encoding is also used by the default three address code representation generated using a local data-flow analysis (see org.opalj.tac.TACAI). In case of the bytecode based data-flow analysis the origin used by the analysis reflects the position of the parameter value on the tac; see org.opalj.ai.parameterIndexToValueOrigin.

  29. class VirtualFormalParameters extends AnyRef

    The set of all explicit and implicit virtual formal method parameters in a project.

    The set of all explicit and implicit virtual formal method parameters in a project. The set also contains virtual formal parameters of library methods.

Value Members

  1. object BasicMethodInfo

    Defines a simplified extractor for a MethodInfo object.

  2. object BasicReport extends Serializable

    Defines factory methods for BasicReports.

  3. object DeclaredMethodsKey extends ProjectInformationKey[DeclaredMethods, Nothing]

    The key object to get information about all declared methods.

    The key object to get information about all declared methods.

    Example:
    1. To get the index use the org.opalj.br.analyses.Project's get method and pass in this object.

    Note

    See org.opalj.br.DeclaredMethod for further details.

  4. object FieldAccessInformationAnalysis

    This analysis determines where each field is accessed.

    This analysis determines where each field is accessed.

    Usage

    Use the FieldAccessInformationKey to query a project about the field access information.

    val accessInformation = project.get(FieldAccessInformationKey)
    Note

    The analysis does not take reflective field accesses into account.

    ,

    The analysis is internally parallelized and should not be run with other analyses in parallel.

    ,

    Fields which are not accessed at all are not further considered.

  5. object FieldAccessInformationKey extends ProjectInformationKey[FieldAccessInformation, Nothing]

    The key object to get global field access information.

    The key object to get global field access information.

    Example:
    1. To get the index use the Project's get method and pass in this object.

  6. object JavaProject
  7. object MethodDeclarationContext

    Definition of factory and extractor methods for MethodDeclarationContext objects.

  8. implicit object MethodDeclarationContextOrdering extends Ordering[MethodDeclarationContext]
  9. object ProgressEvents extends Enumeration

    Characterizes the type of an event related to a running analysis.

    Characterizes the type of an event related to a running analysis.

    See also

    ProgressManagement for further details.

  10. object ProgressManagement

    Factory for a function to create a default progress management object that basically does not track the progress.

  11. object Project

    Definition of factory methods to create Projects.

  12. object ProjectIndex

    Factory for ProjectIndex objects.

  13. object ProjectIndexKey extends ProjectInformationKey[ProjectIndex, Nothing]

    The key object to get an index of the source elements of a project.

    The key object to get an index of the source elements of a project.

    Example:
    1. To get the index use the Project's get method and pass in this object.

  14. object ProjectLike
  15. object ReportableAnalysisResult
  16. object StringConstantsInformationKey extends ProjectInformationKey[StringConstantsInformation, Nothing]

    The key object to get information about all string constants found in the project's code.

    The key object to get information about all string constants found in the project's code.

    Example:
    1. To get the index use the Project's get method and pass in this object.

  17. object VirtualFormalParameter
  18. object VirtualFormalParametersKey extends ProjectInformationKey[VirtualFormalParameters, Nothing]

    The key object to get information about all virtual formal parameters.

    The key object to get information about all virtual formal parameters.

    Example:
    1. To get the index use the org.opalj.br.analyses.Project's get method and pass in this object.

    Note

    See org.opalj.br.analyses.VirtualFormalParameter and VirtualFormalParameters for further details.

Inherited from AnyRef

Inherited from Any

Ungrouped