Namespace Flame.Compiler.Analysis
Classes
AddBasicBlockUpdate
A flow graph update that adds a basic block to the flow graph.
AddInstructionUpdate
A flow graph update that inserts an instruction.
AliasAnalysisResult
A data structure that captures the result of applying alias analysis to a control-flow graph.
BasicBlockFlowUpdate
A flow graph update that sets the outgoing flow of a basic block.
BasicBlockParametersUpdate
A flow graph update that sets the parameters of a basic block.
BasicBlockUpdate
A flow graph update at the basic block level: the insertion, deletion or modification of a basic block.
BlockFixpointAnalysis<TBlockState>
A base class for analyses that process blocks until they reach a fixpoint.
BlockLiveness
Contains value liveness data for a single block.
BlockReachability
A description of which blocks can reach other blocks in a control-flow graph.
ConservativeInstructionOrderingAnalysis
A conservative analysis that determines the must-run-before relation between instructions. The must-run-before relation is determined by imposing a total ordering on effectful instructions.
ConstantAnalysis<T>
An analysis that always returns the same result. This kind of analysis is particularly useful for adding metadata to flow graphs that encode a (user-specified) configuration, such as the exception delayability policy.
DefaultAnalyses
Manages a collection of default control-flow graph analyses, which are used when no analysis is explicitly added to a graph.
DominatorTree
A data structure that describes the dominator tree of a control-flow graph.
DominatorTreeAnalysis
An analysis that computes dominator trees for control-flow graphs.
EffectfulInstructionAnalysis
An analysis that produces the set of all effectful instructions in a graph.
ExceptionDelayability
A base class for rules about whether or not exceptions thrown by particular types of instructions may be delayed until the value they produce is used by an effectful instruction.
ExceptionDelayabilityExtensions
Defines extension methods related to exception delayability.
ExplicitInstructionExceptionSpecs
An explicit mapping of instructions to their exception specifications.
FlowGraphUpdate
Describes an update to a flow graph.
GreedyRegisterAllocator<TRegister>
An analysis that greedily allocates registers to values. The set of values is assumed to be unbounded: the analysis is allowed to "create" an arbitrarily large amount of registers.
InstructionExceptionSpecs
Maps instructions to their exception specifications.
InstructionOrdering
Captures the must-run-before relation between instructions. All instruction orderings that respect this relation are legal and computationally equivalent.
InstructionUpdate
A flow graph update at the instruction level: the insertion, deletion or replacement of an instruction. These updates don't affect the control flow graph itself.
InterferenceGraph
A symmetric relation that tells if there is some point at which two arbitrary values are both live.
InterferenceGraphAnalysis
An analysis that constructs an interference graph.
LatticeAnalysis<TCell>
A base class for flow-sensitive data analyses that assign analysis results to values by repeatedly computing lattice meet operations.
LazyBlockReachability
A block reachability implementation that performs reachability analysis on an on-demand basis and caches the results.
LazyBlockReachabilityAnalysis
An analysis that finds computes block reachability information on an on-demand basis.
LivenessAnalysis
An analysis that determines which variables are live at any location in a control flow graph.
LocalMemorySSAAnalysis
A very simple, block-local memory SSA analysis.
MapMembersUpdate
A flow graph update that applies a mapping to every member in the flow graph.
MemorySpecification
A base class for descriptions of how an instruction interacts with memory.
MemorySpecification.ArgumentRead
A read from an address encoded by an argument.
MemorySpecification.ArgumentWrite
A write to an address encoded by an argument.
MemorySpecification.Union
A union of memory access specs.
MemorySpecificationExtensions
Extension methods that make working with memory specifications easier.
MemorySSA
A mapping of instructions to memory SSA states.
MemorySSA.Phi
A memory SSA phi, which sets the memory state to one of a list of potential memory SSA states.
MemorySSA.Store
A memory SSA value that represents an update of another memory SSA value.
MemorySSA.Unknown
A memory SSA value that represents a completely unknown state.
MemorySSA.Value
A memory SSA value, i.e., a state that memory can have.
NullabilityAnalysis
A simple nullability analysis.
NullCheckExceptionSpecification
An exception specification for an instruction parameter null check.
PermissiveExceptionDelayability
Exception delayability rules that allow delaying exceptions for implicit checks when computing pointers.
PredecessorAnalysis
An analysis that finds basic block predecessors.
PrototypeExceptionSpecs
Maps instruction prototypes to exception specifications.
PrototypeMemorySpecs
Maps instruction prototypes to memory access specs.
ReifiedInstructionExceptionAnalysis
An analysis that infers instruction specification specifications by refining the exception specifications for their prototypes.
RelatedValueAnalysis
An analysis that computes the related value--relation for graphs.
RemoveBasicBlockUpdate
A flow graph update that removes a basic block from the flow graph.
RemoveInstructionUpdate
A flow graph update that removes an instruction.
ReplaceInstructionUpdate
A flow graph update that replaces an instruction.
RuleBasedPrototypeExceptionSpecs
Assigns exception specifications to prototypes based on a set of user-configurable rules.
RuleBasedPrototypeMemorySpecs
Assigns memory specifications to prototypes based on a set of user-configurable rules.
SetEntryPointUpdate
A flow graph update that sets the graph's entry point to a new block.
StrictExceptionDelayability
Exception delayability rules that disallow delaying exceptions in all cases.
TrivialAliasAnalysisResult
A truly trivial alias analysis result implementation: all values are deemed to must-alias themselves and may-alias all other values.
TrivialInstructionExceptionSpecs
An instruction exception specification mapping that trivially copies prototype exception specifications.
ValueNullability
An analysis result that tells if values produce non-null
or dereferenceable pointers.
ValueNumbering
A mapping of values to representative values for a particular control-flow graph.
ValueNumberingAnalysis
An analysis that computes value numbers.
ValueNumberingInstructionComparer
A specialized instruction comparer for instructions that uses value numbers to more accurately compare instructions. Assumes that all instructions being compared are defined by the same graph. The equality relation that arises from this comparer is that of semantic instruction equivalence, not of syntactic equality.
ValueUseAnalysis
An analysis that figures out where values are used.
Structs
BasicBlockPredecessors
A data structure that can be queried to get the predecessors of a block, that is, the set of all blocks that have branches to the block.
BlockFixpointAnalysis<TBlockState>.Result
The result of a block fixpoint analysis.
EffectfulInstructions
The set of instructions in a graph that may have side-effects.
LatticeAnalysisResult<TCell>
The result of a lattice analysis.
RegisterAllocation<TRegister>
An allocation of values to registers.
RelatedValues
A symmetric relation that consists of all pairs of values that are direct copies of each other.
A value is deemed a copy of another value if the former is produced by a copy instruction that references the latter or if the former is a block parameter and there is a branch that specifies the latter as the argument to the former.
This information can be useful for the purpose of register allocation: allocating two related values to the same register will elide a copy.
ValueLiveness
Describes which variables are live at any location in a control flow graph.
ValueUses
A mapping that describes where values are used.
Interfaces
IFlowGraphAnalysis<T>
An analysis on a flow graph.
Enums
Aliasing
Enumerates possible aliasing relations between pointers.