AbstractInterpreter Structure Reference


                    
                    
                    Context

An abstract interpretation context.

Declaration

Swift

typealias Context = AbstractContext<Domain>

Show on GitHub


                    
                    
                    BlockState

The knowledge of the abstract interpreter about a single block.

Declaration

Swift

typealias BlockState = (sources: Set<Function.Blocks.Address>, before: Context, after: Context)

Show on GitHub


                    
                    
                    State

A map from function block to the context of the abstract interpreter before and after the evaluation of its instructions.

Declaration

Swift

typealias State = [Function.Blocks.Address : BlockState]

Show on GitHub


                    
                    
                    Interpret

A closure that processes block in context.

Declaration

Swift

typealias Interpret = (_ block: Function.Blocks.Address, _ context: inout Context) -> Void

Show on GitHub


                    
                    
                    subject

The function being interpreted.

Declaration

Swift

private let subject: Function.ID

Show on GitHub

cfg

The control flow graph of the function being interpreted.

Declaration

Swift

private var cfg: ControlFlowGraph

Show on GitHub


                    
                    
                    dominatorTree

The dominator tree of the function being interpreted.

Declaration

Swift

private var dominatorTree: DominatorTree

Show on GitHub


                    
                    
                    state

The state of the abstract interpreter before and after the visited basic blocks.

Declaration

Swift

private var state: State

Show on GitHub


                    
                    
                    work

A FILO list of blocks to visit.

Declaration

Swift

private var work: Deque<Function.Blocks.Address>

Show on GitHub


                    
                    
                    done

The set of blocks that no longer need to be visited.

Declaration

Swift

private var done: Set<Function.Blocks.Address>

Show on GitHub


                    
                    
                    init(analyzing:in:entryContext:)

Creates an interpreter analyzing f which is in m, starting with entryContext.

Declaration

Swift

init(
  analyzing f: Function.ID,
  in m: Module,
  entryContext: Context
)

Show on GitHub


                    
                    
                    recomputeControlFlow(_:)

Recomputes the CFG of the function being interpreted.

Call this method to update the control-flow information used by this instance to guide abstract interpretation.

Declaration

Swift

mutating func recomputeControlFlow(_ m: Module)

Show on GitHub


                    
                    
                    removeWork(_:)

Removes b from the work list.

Requires

b is in the work list.

Declaration

Swift

mutating func removeWork(_ b: Function.Blocks.Address)

Show on GitHub


                    
                    
                    addWork(_:)

Adds b to the work list.

Requires

b is a basic block of the function being analyzed.

Declaration

Swift

mutating func addWork(_ b: Function.Blocks.Address)

Show on GitHub


                    
                    
                    fixedPoint(_:)

Runs this instance using interpret to interpret basic blocks.

Declaration

Swift

mutating func fixedPoint(_ interpret: Interpret)

Show on GitHub


                    
                    
                    visited(_:)

Returns true if b has been visited.

Declaration

Swift

private func visited(_ b: Function.Blocks.Address) -> Bool

Show on GitHub


                    
                    
                    isVisitable(_:)

Returns true if b is ready to be visited.

Computing the before-context of b requires knowing the state of all uses in b that are defined its (transitive) predecessors. Because a definition must dominate all its uses, we can assume the predecessors dominated by b don’t define variables used in b. Hence, b can be visited iff all its predecessors have been visited or are dominated by b.

Declaration

Swift

private func isVisitable(_ b: Function.Blocks.Address) -> Bool

Show on GitHub


                    
                    
                    beforeContext(of:)

Returns the before-context of b and the predecessors from which it’s been computed.

Requires

isVisitable(b) is true

Declaration

Swift

private func beforeContext(
  of b: Function.Blocks.Address
) -> (sources: Set<Function.Blocks.Address>, before: Context)

Show on GitHub


                    
                    
                    afterContext(of:in:processingBlockWith:)

Returns the after-context of b by processing it with interpret in initialContext.

Declaration

Swift

mutating func afterContext(
  of b: Function.Blocks.Address,
  in initialContext: Context,
  processingBlockWith interpret: Interpret
) -> Context

Show on GitHub