Show / Hide Table of Contents

    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.

    Back to top Generated by DocFX