ForwardFlowAnalysis (Java Assembler / Disassembler (Jasm) 1.0 API)

java.lang.Object
- jasm.util.dfa.ForwardFlowAnalysis<T>

Direct Known Subclasses:

TypeAnalysis
```
public abstract class ForwardFlowAnalysis<T>
extends Object
```
Represents a generic forward dataflow analysis. This user must implement the transfer functions for the different kinds of bytecode, and the analysis will propagate until a fixed point is reached.

Author:

David J. Pearce

Constructor Summary

Constructors
Constructor and Description

ForwardFlowAnalysis()

Constructors
Constructor and Description
`ForwardFlowAnalysis()`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`T[]`	`apply(ClassFile.Method method)`
`abstract T[]`	`initialise(Code attribute, ClassFile.Method method)` Generate an array of stores, one for each bytecode in the given method.
`protected void`	`merge(int index, T store, HashSet<Integer> worklist, T[] stores)`
`abstract boolean`	`merge(int index, T original, T update)` Merge one abstract store into another to form a store at a join point in the control-flow graph.
`protected int`	`select(HashSet<Integer> worklist)`
`abstract T`	`transfer(int index, boolean branch, Bytecode.IfCmp bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a given bytecode to an incoming store.
`abstract T`	`transfer(int index, boolean branch, Bytecode.If bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a given bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.ArrayLength bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a arraystore bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.ArrayLoad bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a arrayload bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.ArrayStore bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a arraystore bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.BinOp bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a binop bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.CheckCast bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a checkcast bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.Cmp bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a cmp bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.Conversion bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a convert bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.Dup bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a dup bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.DupX1 bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a dup_x1 bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.DupX2 bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a dup_x2 bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.GetField bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a getfield bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.Iinc bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of an iinc bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.InstanceOf bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a instanceof bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.Invoke bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a invoke bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.LoadConst bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a loadconst bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.Load bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a load bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.MonitorEnter bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a monitorenter bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.MonitorExit bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a monitorexit bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.Neg bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a neg bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.New bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a new bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.Nop bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a nop bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.Pop bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a pop bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.PutField bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a arraystore bytecode to an incoming store.
`abstract void`	`transfer(int index, Bytecode.Return bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a return bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.Store bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a store bytecode to an incoming store.
`abstract T`	`transfer(int index, Bytecode.Swap bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a swap bytecode to an incoming store.
`abstract void`	`transfer(int index, Bytecode.Throw bytecode, T store)` Generate an updated a abstract store by apply the abstract effect(s) of a throw bytecode to an incoming store.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - ForwardFlowAnalysis
```
public ForwardFlowAnalysis()
```
- Method Detail
  - apply
```
public T[] apply(ClassFile.Method method)
```
    Parameters:
    
    method -
  - select
```
protected int select(HashSet<Integer> worklist)
```
  - merge
```
protected void merge(int index,
                     T store,
                     HashSet<Integer> worklist,
                     T[] stores)
```
  - initialise
```
public abstract T[] initialise(Code attribute,
                               ClassFile.Method method)
```
    Generate an array of stores, one for each bytecode in the given method. The initial store (i.e. at index zero) is the initial store for the method. initial store for the given method.
    
    Parameters:
    
    attribute - code attribute being analysed.
    
    method - enclosing method.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.Store bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a store bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.Load bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a load bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.LoadConst bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a loadconst bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.ArrayLoad bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a arrayload bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.ArrayStore bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a arraystore bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.GetField bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a getfield bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.PutField bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a arraystore bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.ArrayLength bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a arraystore bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.Invoke bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a invoke bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract void transfer(int index,
                              Bytecode.Throw bytecode,
                              T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a throw bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
  - transfer
```
public abstract void transfer(int index,
                              Bytecode.Return bytecode,
                              T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a return bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.Iinc bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of an iinc bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.BinOp bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a binop bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.Neg bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a neg bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.New bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a new bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.CheckCast bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a checkcast bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.Conversion bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a convert bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.InstanceOf bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a instanceof bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.Pop bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a pop bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.Dup bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a dup bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.DupX1 bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a dup_x1 bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.DupX2 bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a dup_x2 bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.Swap bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a swap bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.Cmp bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a cmp bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.Nop bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a nop bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.MonitorEnter bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a monitorenter bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           Bytecode.MonitorExit bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a monitorexit bytecode to an incoming store.
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    bytecode - bytecode to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           boolean branch,
                           Bytecode.If bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a given bytecode to an incoming store. In this case, the bytecode in question is branching, and we must consider which branch is being analysed (either the true branch, or the false branch).
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    branch - indicates the true or false branch is to be considered.
    
    bytecode - to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - transfer
```
public abstract T transfer(int index,
                           boolean branch,
                           Bytecode.IfCmp bytecode,
                           T store)
```
    Generate an updated a abstract store by apply the abstract effect(s) of a given bytecode to an incoming store. In this case, the bytecode in question is branching, and we must consider which branch is being analysed (either the true branch, or the false branch).
    
    Parameters:
    
    index - index in bytecode array of bytecode being analysed.
    
    branch - indicates the true or false branch is to be considered.
    
    bytecode - to be analysed.
    
    store - incoming abstract store.
    
    Returns:
  - merge
```
public abstract boolean merge(int index,
                              T original,
                              T update)
```
    Merge one abstract store into another to form a store at a join point in the control-flow graph.
    
    Parameters:
    
    index - Index position of bytecode being analysed
    
    original - Original store to join "into". In the case of no change, this should be returned.
    
    update - New store to join "into" the original store.
    
    Returns:
    
    true if the store was changed.

Class ForwardFlowAnalysis<T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ForwardFlowAnalysis

Method Detail

apply

select

merge

initialise

transfer

transfer

transfer

transfer

transfer

transfer

transfer

transfer

transfer

transfer

transfer

transfer

transfer

transfer

transfer

transfer

transfer

transfer

transfer

transfer

transfer

transfer

transfer

transfer

transfer

transfer

transfer

transfer

transfer

merge