Package harpoon.Analysis

This package contains analysis routines applicable to a variety of intermediate representations.

See:
Description

Interface Summary

AllCallers.MethodSet	MethodSet defines the interface whose method select is used in getCallers as a predicate.
BasicBlockFactoryInterf<HCE extends HCodeElement,BB extends BasicBlockInterf<HCE,BB>>	BasicBlockFactoryInterf
BasicBlockInterf<HCE extends HCodeElement,BB extends BasicBlockInterf>	BasicBlockInterf is the interface that needs to be implemented by any "basic block"-like structure.
InterferenceGraph	InterferenceGraph is an abstract interface for interference graphs.
PointsToAnalysis.Node<HCE extends HCodeElement>	PointsToAnalysis.Node is just a marker interface for the nodes in the points-to graph returned by the PointsToAnalysis interface.

Class Summary

AbstractClassFixupRelinker	AbstractClassFixupRelinker is an extension of Relinker which fixes up abstract classes so that they implement all the methods of their interfaces (even if this implementation is via an abstract method declaration).
AllCallers	AllCallers calculates the transitive closure of the dual of the call graph for methods that fulfill a certain condition.
AllocationInformationMap<HCE extends HCodeElement>	An AllocationInformationMap makes it easy to create a map-based AllocationInformation structure.
AllocationInformationMap.AllocationPropertiesImpl	A simple implementation of AllocationProperties.
BasicBlock<HCE extends HCodeElement>	BasicBlock collects a sequence of operations.
BasicBlock.Factory<HCE extends HCodeElement>	Factory structure for generating BasicBlock views of an HCode.
BasicBlockInterfVisitor	BasicBlockInterfVisitor is a visitor class implemented similarly to QuadVisitor, with the idea that we may eventually have different kinds of basic blocks.
CallGraph	CallGraph is a general IR-independant interface that for a call graph.
ChainedAllocationProperties	ChainedAllocationProperties allows us to change several properties of an already existing AllocationProperties.
ClassHierarchy	A ClassHierarchy enumerates reachable/usable classes and callable methods.
Context<E>	A Context object is an opaque representation of a method's calling context, intended to make it easier to generalize across context-sensitive and context-insensitive analyses.
CycleEq	CycleEq computes cycle equivalence classes for edges in a control flow graph, in O(E) time.
DefaultAllocationInformation	DefaultAllocationInformation returns a simple no-analysis AllocationInformation structure which works for allocation sites in quad form.
DefaultAllocationInformationMap	DefaultAllocationInformationMap is a combination of AllocationInformationMap and DefaultAllocationInformation.
DomFrontier	DomFrontier computes the dominance frontier of a flowgraph-structured IR.
DomTree<HCE extends HCodeElement>	DomTree computes the dominator tree of a flowgraph-structured IR.
EdgesIterator	EdgesIterator is a generic iterator for a set of CFGraphable objects.
FCFGBasicBlock	FCFGBasicBlock is a basic block structure for the Factored Control Flow Graph (FCFG) representation.
FCFGBasicBlock.Factory	Factory structure for generating FCFGBasicBlock views of an HCode.
GenericContextFactory<E>	A GenericContextFactory can create Context objects for any desired level of context-sensitivity.
IOEffectAnalysis	IOEffectAnalysis is a simple analysis that detects whether a method may (transitively) execute an input/output operation.
Liveness<HCE extends HCodeElement>	Liveness defines an abstract class for live variable analysis.
Place	Place determines the proper locations for phi/sigma functions.
PointsToAnalysis<HCE extends HCodeElement,NODE extends PointsToAnalysis.Node<HCE>,CONTEXT extends Context>	The PointsToAnalysis interface encapsulates a points-to pointer analysis algorithm, allowing transformation and analysis code to use the results of a PointsToAnalysis w/o knowing the details of its implementation.
Reachable<HCE extends HCodeElement>	Reachable
ReachingDefs<HCE extends HCodeElement>	ReachingDefs defines an abstract class for analyzing reaching definitions.
ReachingDefsAltImpl<HCE extends HCodeElement>	ReachingDefsAltImpl
ReachingDefsCachingImpl<HCE extends HCodeElement>	ReachingDefsCachingImpl is an extension of ReachingDefsImpl that keeps a BasicBlock local cache mapping Temp:t -> HCodeElement:h -> Set:s where s is the result of calling reachingDefs(h, t).
ReachingDefsImpl<HCE extends HCodeElement>	ReachingDefsImpl defines an implementation for analyzing reaching definitions.
SESE	SESE computes nested single-entry single-exit regions from a cycle-equivalency set.
SESE.Region	SESE.Region represents a single-entry single-exit (SESE) Region, as computed by the SESE object.
SSxReachingDefsImpl<HCE extends HCodeElement>	SSxReachingDefsImpl is a ReachingDefs implementation that works on codeviews in SSA or SSI form.
UseDef<HCE extends HCodeElement>	UseDef objects map Temps to the HCodeElements which use or define them.
UseDefChecker	UseDefChecker verifies that all variables are defined before they are used.
UseDefChecker.ReachingDefsFactory	The UseDefChecker constructor takes a ReachingDefsFactory argument to specify which ReachingDefs implementation it should use.

Package harpoon.Analysis Description

This package contains analysis routines applicable to a variety of intermediate representations. Typically, the only requirement is that the IR implement some set of properties from harpoon.IR.Properties.

IR-specific analysis should not be placed in this package. In addition, if you analysis is very complicated, you should also create a separate package for it. Primarily basic compiler algorithms go here, including construction of dominance trees and frontiers and basic graph algorithms.

Author:

various