LocalMustAliasAnalysis

java.lang.Object
- soot.toolkits.scalar.AbstractFlowAnalysis<N,A>
- - soot.toolkits.scalar.FlowAnalysis<N,A>
  - - soot.toolkits.scalar.ForwardFlowAnalysis<Unit,java.util.HashMap<Value,java.lang.Integer>>
    - - soot.jimple.toolkits.pointer.LocalMustAliasAnalysis

Direct Known Subclasses:

StrongLocalMustAliasAnalysis
```
public class LocalMustAliasAnalysis
extends ForwardFlowAnalysis<Unit,java.util.HashMap<Value,java.lang.Integer>>
```
LocalMustAliasAnalysis attempts to determine if two local variables (at two potentially different program points) must point to the same object. The underlying abstraction is based on global value numbering. See also StrongLocalMustAliasAnalysis for an analysis that soundly treats redefinitions within loops. See Sable TR 2007-8 for details. P.S. The idea behind this analysis and the way it assigns numbers is very similar to what is described in the paper: Lapkowski, C. and Hendren, L. J. 1996. Extended SSA numbering: introducing SSA properties to languages with multi-level pointers. In Proceedings of the 1996 Conference of the Centre For Advanced Studies on Collaborative Research (Toronto, Ontario, Canada, November 12 - 14, 1996). M. Bauer, K. Bennet, M. Gentleman, H. Johnson, K. Lyons, and J. Slonim, Eds. IBM Centre for Advanced Studies Conference. IBM Press, 23. Only major differences: Here we only use primary numbers, no secondary numbers. Further, we use the call graph to determine fields that are not written to in the transitive closure of this method's execution. A third difference is that we assign fixed values to IdentityRefs, because those never change during one execution.

See Also:

StrongLocalMustAliasAnalysis

Nested Class Summary
- Nested classes/interfaces inherited from class soot.toolkits.scalar.FlowAnalysis
  FlowAnalysis.Flow

Field Summary

Fields
Modifier and Type	Field and Description
`protected SootMethod`	`container` the containing method
`protected java.util.Set<Value>`	`localsAndFieldRefs` The set of all local variables and field references that we track.
`protected java.util.Map<Unit,java.util.Map<Value,java.lang.Integer>>`	`mergePointToValueToNumber` maps from a merge point (a unit) and a value to the unique value number of that value at this point
`protected int`	`nextNumber` the next value number
`protected java.util.Map<Value,java.lang.Integer>`	`rhsToNumber` maps from right-hand side expressions (non-locals) to value numbers

Fields inherited from class soot.toolkits.scalar.FlowAnalysis
filterUnitToAfterFlow, unitToAfterFlow

Fields inherited from class soot.toolkits.scalar.AbstractFlowAnalysis
filterUnitToBeforeFlow, graph, unitToBeforeFlow

Constructor Summary

Constructors
Constructor and Description
`LocalMustAliasAnalysis(UnitGraph g)` Creates a new `LocalMustAliasAnalysis` tracking local variables.
`LocalMustAliasAnalysis(UnitGraph g, boolean tryTrackFieldAssignments)` Creates a new `LocalMustAliasAnalysis`.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`copy(java.util.HashMap<Value,java.lang.Integer> sourceMap, java.util.HashMap<Value,java.lang.Integer> destMap)` Creates a copy of the `source` flow object in `dest`.
`protected java.util.HashMap<Value,java.lang.Integer>`	`entryInitialFlow()` Initial most conservative value: We leave it away to save memory, implicitly UNKNOWN.
`protected void`	`flowThrough(java.util.HashMap<Value,java.lang.Integer> in, Unit u, java.util.HashMap<Value,java.lang.Integer> out)` Given the merge of the `out` sets, compute the `in` set for `s` (or in to out, depending on direction).
`boolean`	`hasInfoOn(Local l, Stmt s)` Returns true if this analysis has any information about local l at statement s.
`java.lang.String`	`instanceKeyString(Local l, Stmt s)` Returns a string (natural number) representation of the instance key associated with l at statement s or `null` if there is no such key associated.
`protected void`	`merge(java.util.HashMap<Value,java.lang.Integer> in1, java.util.HashMap<Value,java.lang.Integer> in2, java.util.HashMap<Value,java.lang.Integer> out)` Compute the merge of the `in1` and `in2` sets, putting the result into `out`.
`protected void`	`merge(Unit succUnit, java.util.HashMap<Value,java.lang.Integer> inMap1, java.util.HashMap<Value,java.lang.Integer> inMap2, java.util.HashMap<Value,java.lang.Integer> outMap)` Merges in1 and in2 into out, just before node succNode.
`boolean`	`mustAlias(Local l1, Stmt s1, Local l2, Stmt s2)`
`protected java.util.HashMap<Value,java.lang.Integer>`	`newInitialFlow()` Initial bottom value: objects have no definitions.
`static int`	`parameterRefNumber(ParameterRef r)`
`static int`	`thisRefNumber()`

Methods inherited from class soot.toolkits.scalar.ForwardFlowAnalysis
doAnalysis, isForward

Methods inherited from class soot.toolkits.scalar.FlowAnalysis
getFlow, getFlowAfter, getFlowBefore, omissible

Methods inherited from class soot.toolkits.scalar.AbstractFlowAnalysis
mergeInto, treatTrapHandlersAsEntries

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

- Field Detail
  - localsAndFieldRefs
```
protected java.util.Set<Value> localsAndFieldRefs
```
    The set of all local variables and field references that we track. This set contains objects of type Local and, if tryTrackFieldAssignments is enabled, it may also contain EquivalentValues of FieldRefs. If so, these field references are to be tracked on the same way as Locals are.
  - rhsToNumber
```
protected transient java.util.Map<Value,java.lang.Integer> rhsToNumber
```
    maps from right-hand side expressions (non-locals) to value numbers
  - mergePointToValueToNumber
```
protected transient java.util.Map<Unit,java.util.Map<Value,java.lang.Integer>> mergePointToValueToNumber
```
    maps from a merge point (a unit) and a value to the unique value number of that value at this point
  - nextNumber
```
protected int nextNumber
```
    the next value number
  - container
```
protected SootMethod container
```
    the containing method
- Constructor Detail
  - LocalMustAliasAnalysis
```
public LocalMustAliasAnalysis(UnitGraph g)
```
    Creates a new LocalMustAliasAnalysis tracking local variables.
  - LocalMustAliasAnalysis
```
public LocalMustAliasAnalysis(UnitGraph g,
                              boolean tryTrackFieldAssignments)
```
    Creates a new LocalMustAliasAnalysis. If tryTrackFieldAssignments, we run an interprocedural side-effects analysis to determine which fields are (transitively) written to by this method. All fields which that are not written to are tracked just as local variables. This semantics is sound for single-threaded programs.
- Method Detail
  - merge
```
protected void merge(Unit succUnit,
                     java.util.HashMap<Value,java.lang.Integer> inMap1,
                     java.util.HashMap<Value,java.lang.Integer> inMap2,
                     java.util.HashMap<Value,java.lang.Integer> outMap)
```
    Description copied from class: AbstractFlowAnalysis
    
    Merges in1 and in2 into out, just before node succNode. By default, this method just calls merge(A,A,A), ignoring the node.
    
    Overrides:
    
    merge in class AbstractFlowAnalysis<Unit,java.util.HashMap<Value,java.lang.Integer>>
  - flowThrough
```
protected void flowThrough(java.util.HashMap<Value,java.lang.Integer> in,
                           Unit u,
                           java.util.HashMap<Value,java.lang.Integer> out)
```
    Description copied from class: FlowAnalysis
    
    Given the merge of the out sets, compute the in set for s (or in to out, depending on direction). This function often causes confusion, because the same interface is used for both forward and backward flow analyses. The first parameter is always the argument to the flow function (i.e. it is the "in" set in a forward analysis and the "out" set in a backward analysis), and the third parameter is always the result of the flow function (i.e. it is the "out" set in a forward analysis and the "in" set in a backward analysis).
    
    Specified by:
    
    flowThrough in class FlowAnalysis<Unit,java.util.HashMap<Value,java.lang.Integer>>
    
    Parameters:
    
    in - the input flow
    
    u - the current node
    
    out - the returned flow
  - thisRefNumber
```
public static int thisRefNumber()
```
  - parameterRefNumber
```
public static int parameterRefNumber(ParameterRef r)
```
  - copy
```
protected void copy(java.util.HashMap<Value,java.lang.Integer> sourceMap,
                    java.util.HashMap<Value,java.lang.Integer> destMap)
```
    Description copied from class: AbstractFlowAnalysis
    
    Creates a copy of the source flow object in dest.
    
    Specified by:
    
    copy in class AbstractFlowAnalysis<Unit,java.util.HashMap<Value,java.lang.Integer>>
  - entryInitialFlow
```
protected java.util.HashMap<Value,java.lang.Integer> entryInitialFlow()
```
    Initial most conservative value: We leave it away to save memory, implicitly UNKNOWN.
    
    Overrides:
    
    entryInitialFlow in class AbstractFlowAnalysis<Unit,java.util.HashMap<Value,java.lang.Integer>>
  - newInitialFlow
```
protected java.util.HashMap<Value,java.lang.Integer> newInitialFlow()
```
    Initial bottom value: objects have no definitions.
    
    Specified by:
    
    newInitialFlow in class AbstractFlowAnalysis<Unit,java.util.HashMap<Value,java.lang.Integer>>
  - instanceKeyString
```
public java.lang.String instanceKeyString(Local l,
                                          Stmt s)
```
    Returns a string (natural number) representation of the instance key associated with l at statement s or null if there is no such key associated.
    
    Parameters:
    
    l - any local of the associated method
    
    s - the statement at which to check
  - hasInfoOn
```
public boolean hasInfoOn(Local l,
                         Stmt s)
```
    Returns true if this analysis has any information about local l at statement s. In particular, it is safe to pass in locals/statements that are not even part of the right method. In those cases false will be returned. Permits s to be null, in which case false will be returned.
  - mustAlias
```
public boolean mustAlias(Local l1,
                         Stmt s1,
                         Local l2,
                         Stmt s2)
```
    Returns:
    
    true if values of l1 (at s1) and l2 (at s2) have the exact same object IDs, i.e. at statement s1 the variable l1 must point to the same object as l2 at s2.
  - merge
```
protected void merge(java.util.HashMap<Value,java.lang.Integer> in1,
                     java.util.HashMap<Value,java.lang.Integer> in2,
                     java.util.HashMap<Value,java.lang.Integer> out)
```
    Description copied from class: AbstractFlowAnalysis
    
    Compute the merge of the in1 and in2 sets, putting the result into out. The behavior of this function depends on the implementation ( it may be necessary to check whether in1 and in2 are equal or aliased ). Used by the doAnalysis method.
    
    Specified by:
    
    merge in class AbstractFlowAnalysis<Unit,java.util.HashMap<Value,java.lang.Integer>>

Class LocalMustAliasAnalysis

Nested Class Summary

Nested classes/interfaces inherited from class soot.toolkits.scalar.FlowAnalysis

Field Summary

Fields inherited from class soot.toolkits.scalar.FlowAnalysis

Fields inherited from class soot.toolkits.scalar.AbstractFlowAnalysis

Constructor Summary

Method Summary

Methods inherited from class soot.toolkits.scalar.ForwardFlowAnalysis

Methods inherited from class soot.toolkits.scalar.FlowAnalysis

Methods inherited from class soot.toolkits.scalar.AbstractFlowAnalysis

Methods inherited from class java.lang.Object

Field Detail

localsAndFieldRefs

rhsToNumber

mergePointToValueToNumber

nextNumber

container

Constructor Detail

LocalMustAliasAnalysis

LocalMustAliasAnalysis

Method Detail

merge

flowThrough

thisRefNumber

parameterRefNumber

copy

entryInitialFlow

newInitialFlow

instanceKeyString

hasInfoOn

mustAlias

merge