OPAL is a Scala-based framework for the static analysis, manipulation and creation of Java bytecode.
Implementation of an abstract interpretation (ai) framework – also referred to as OPAL.
This framework assumes that the analyzed bytecode is valid; i.e., the JVM's
bytecode verifier would be able to verify the code. Furthermore, load-time errors
LinkageErrors) are – by default – completely ignored to facilitate the
analysis of parts of a project. In general, if the presented bytecode is not valid,
the result is undefined (i.e., OPAL may report meaningless results, crash or run
org.opalj.ai.AI - Implements the abstract interpreter that processes a methods code and uses an analysis-specific domain to perform the abstract computations.
org.opalj.ai.Domain - The core interface between the abstract interpretation framework and the abstract domain that is responsible for performing the abstract computations.
Helper classes and functionality related to specifying architectural concerns.
Implementation of an eDSL for creating Java bytecode.
Implementation of a library for parsing Java bytecode and creating arbitrary representations.
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.
Defines functionality commonly useful when processing Java bytecode.
OPAL's collection library is primarily designed with high performance in mind.
Common constants, factory methods and objects used throughout OPAL when performing concurrent computations.
Defines helper values and methods related to modeling constraints.
Defines common control abstractions.
Defines convenience methods related to representing certain class file elements.
Functionality to extract dependencies between class files.
The fixpoint computations framework (
fpcf) is a general framework to perform fixpoint
computations of properties ordered by a lattice.
This framework assumes that all data-structures (e.g., dependee lists and properties) that are passed to the framework are effectively immutable! (Effectively immutable means that a data structure is never updated after it was passed to the framework.),
The dependency relation is as follows:
“A depends on B”
“A is the depender, B is the dependee”.
“B is depended on by A”
The very core of the framework is described in: Lattice Based Modularization of Static Analyses
This package defines graph algorithms as well as factory methods to describe and compute graphs and trees.
Various io-related helper methods and classes.
The implementations of the methods rely on Java NIO(2).
Defines implicit conversions to wrap some types of analyses such that they generate results of type org.opalj.br.analyses.ReportableAnalysisResult.
Common definitions related to the definition and processing of three address code.
Provides a general query interface for querying a value's properties.