com.oracle.graal.pointsto.flow

Class TypeFlow<T>

java.lang.Object

com.oracle.graal.pointsto.flow.TypeFlow<T>

Direct Known Subclasses:

AccessFieldTypeFlow, ActualParameterTypeFlow, ActualReturnTypeFlow, AllInstantiatedTypeFlow, AllSynchronizedTypeFlow, ArrayCopyTypeFlow, ArrayElementsTypeFlow, CloneTypeFlow, ConstantTypeFlow, DynamicNewInstanceTypeFlow, FieldFilterTypeFlow, FieldTypeFlow, FilterTypeFlow, FormalParamTypeFlow, FormalReturnTypeFlow, FrozenFieldFilterTypeFlow, InstanceOfTypeFlow, InvokeTypeFlow, MergeTypeFlow, MethodTypeFlow, MonitorEnterTypeFlow, NewInstanceTypeFlow, NullCheckTypeFlow, OffsetLoadTypeFlow, OffsetStoreTypeFlow, ProxyTypeFlow, SourceTypeFlow, UnsafeWriteSinkTypeFlow

public abstract class TypeFlow<T>
extends Object

Field Summary

Fields

Modifier and Type	Field and Description
protected AnalysisType	declaredType
protected MethodFlowsGraph	graphRef
protected int	id
boolean	inQueue
protected static AtomicInteger	nextId
protected T	source
protected TypeState	state

Constructor Summary

Constructors

Constructor and Description
TypeFlow()
TypeFlow(T source, AnalysisType declaredType)
TypeFlow(T source, AnalysisType declaredType, boolean canBeNull)
TypeFlow(T source, AnalysisType declaredType, TypeState state)
TypeFlow(TypeFlow<T> original, MethodFlowsGraph graphRef) Shallow copy constructor.
TypeFlow(TypeFlow<T> original, MethodFlowsGraph graphRef, TypeState cloneState)
TypeFlow(TypeState typeState)

Method Summary

Modifier and Type	Method and Description
void	addInput(TypeFlow<?> input)
void	addObservee(TypeFlow<?> observee)
void	addObserver(PointsToAnalysis bb, TypeFlow<?> observer) Register object that will be notified when the state of this flow changes.
boolean	addObserver(PointsToAnalysis bb, TypeFlow<?> observer, boolean triggerUpdate)
boolean	addState(PointsToAnalysis bb, TypeState add)
boolean	addState(PointsToAnalysis bb, TypeState add, boolean postFlow)
boolean	addUse(PointsToAnalysis bb, TypeFlow<?> use)
boolean	addUse(PointsToAnalysis bb, TypeFlow<?> use, boolean propagateTypeState)
boolean	canSaturate() Can this type flow saturate? By default all type flows can saturate, with the exception of a few ones that need to track all their types, e.g., AllInstantiated, AllSynchronized, etc.
void	clearInputs()
void	clearObservees()
void	clearObservers()
void	clearUses()
TypeFlow<T>	copy(PointsToAnalysis bb, MethodFlowsGraph methodFlows) By default a type flow is not cloneable.
TypeState	declaredTypeFilter(PointsToAnalysis bb, TypeState newState) Filter type states using a flow's declared type.
TypeState	declaredTypeFilter(PointsToAnalysis bb, TypeState newState, boolean onlyWithRelaxedTypeFlowConstraints)
protected boolean	doAddUse(PointsToAnalysis bb, TypeFlow<?> use)
boolean	equals(Object other)
TypeState	filter(PointsToAnalysis bb, TypeState newState)
static AnalysisType	filterUncheckedInterface(AnalysisType type) In Java, interface types are not checked by the bytecode verifier.
String	format(boolean withState, boolean withSource)
String	formatSource()
AnalysisType	getDeclaredType()
Collection<TypeFlow<?>>	getInputs()
Collection<TypeFlow<?>>	getObservees()
Collection<TypeFlow<?>>	getObservers()
int	getSlot()
T	getSource()
TypeState	getState()
Collection<TypeFlow<?>>	getUses()
MethodFlowsGraph	graphRef()
int	hashCode()
int	id()
void	initFlow(PointsToAnalysis bb) Initialization code for some type flow corner cases.
void	invalidate() Invalidating the typeflow will cause the flow to be lazily removed in the future.
boolean	isAllInstantiated()
boolean	isClone()
boolean	isContextInsensitive()
boolean	isSaturated() Return true if this flow is saturated.
boolean	isValid() Return true is the flow is valid and should be updated.
AnalysisMethod	method()
boolean	needsInitialization() Type flows that require initialization after the graph is created need to override this method and return true.
protected void	notifyObserverOfSaturation(PointsToAnalysis bb, TypeFlow<?> observer)
protected void	notifyUseOfSaturation(PointsToAnalysis bb, TypeFlow<?> use)
protected void	onInputSaturated(PointsToAnalysis bb, TypeFlow<?> input) Notified by an input that it is saturated and it will stop sending updates.
void	onObservedSaturated(PointsToAnalysis bb, TypeFlow<?> observed) Notified by an observed flow that it is saturated.
void	onObservedUpdate(PointsToAnalysis bb) Notify the observer that the observed type flow state has changed.
protected void	onSaturated()
protected void	onSaturated(PointsToAnalysis bb) Called when this type flow becomes saturated.
TypeFlow<?>	receiver() Some flows have a receiver (e.g., loads, store and invokes).
boolean	removeObserver(TypeFlow<?> observer)
boolean	removeUse(TypeFlow<?> use)
void	replacedObservedWith(PointsToAnalysis bb, TypeFlow<?> newObservedFlow)
void	replaceObservedWith(PointsToAnalysis bb, AnalysisType newObservedType) When an "observed -> observer" link is updated the observer needs to be notified as well so it can update its internal reference.
protected void	setObserved(TypeFlow<?> newObservedFlow) Set the type flow that this flow is observing.
void	setSaturated() Mark this flow as saturated.
void	setSlot(int slot)
void	setState(PointsToAnalysis bb, TypeState state)
protected void	swapAtObserver(PointsToAnalysis bb, TypeFlow<?> newFlow, TypeFlow<?> observer)
protected void	swapAtUse(PointsToAnalysis bb, TypeFlow<?> newFlow, TypeFlow<?> use)
protected void	swapOut(PointsToAnalysis bb, TypeFlow<?> newFlow) This flow will swap itself out at all uses and observers.
String	toString()
void	update(PointsToAnalysis bb)

Methods inherited from class java.lang.Object

clone, getClass, notify, notifyAll, wait, wait, wait

Field Detail

nextId

protected static final AtomicInteger nextId

id

protected final int id

source

protected T source

declaredType

protected final AnalysisType declaredType

state

protected volatile TypeState state

graphRef

protected final MethodFlowsGraph graphRef

inQueue

public volatile boolean inQueue

Constructor Detail

TypeFlow

public TypeFlow()

TypeFlow

public TypeFlow(TypeState typeState)

TypeFlow

public TypeFlow(T source,
                AnalysisType declaredType)

TypeFlow

public TypeFlow(T source,
                AnalysisType declaredType,
                boolean canBeNull)

TypeFlow

public TypeFlow(T source,
                AnalysisType declaredType,
                TypeState state)

TypeFlow

public TypeFlow(TypeFlow<T> original,
                MethodFlowsGraph graphRef)

Shallow copy constructor. Does not copy the flows or the state.

Parameters:

original - the original flow

graphRef - the holder method clone

TypeFlow

public TypeFlow(TypeFlow<T> original,
                MethodFlowsGraph graphRef,
                TypeState cloneState)

Method Detail

copy

public TypeFlow<T> copy(PointsToAnalysis bb,
                        MethodFlowsGraph methodFlows)

By default a type flow is not cloneable.

Parameters:

bb -

methodFlows -

initFlow

public void initFlow(PointsToAnalysis bb)

Initialization code for some type flow corner cases. TypeFlow.needsInitialization() also needs to be overridden to enable type flow initialization.

Parameters:

bb -

needsInitialization

public boolean needsInitialization()

Type flows that require initialization after the graph is created need to override this method and return true.

receiver

public TypeFlow<?> receiver()

Some flows have a receiver (e.g., loads, store and invokes).

id

public int id()

graphRef

public MethodFlowsGraph graphRef()

method

public AnalysisMethod method()

getSource

public T getSource()

isClone

public boolean isClone()

isContextInsensitive

public boolean isContextInsensitive()

getDeclaredType

public AnalysisType getDeclaredType()

getState

public TypeState getState()

isAllInstantiated

public boolean isAllInstantiated()

setState

public void setState(PointsToAnalysis bb,
                     TypeState state)

setSlot

public void setSlot(int slot)

getSlot

public int getSlot()

isValid

public boolean isValid()

Return true is the flow is valid and should be updated.

invalidate

public void invalidate()

Invalidating the typeflow will cause the flow to be lazily removed in the future.

isSaturated

public boolean isSaturated()

Return true if this flow is saturated. When an observer becomes saturated it doesn't immediately remove itself from all its inputs. The inputs lazily remove it on next update.

canSaturate

public boolean canSaturate()

Can this type flow saturate? By default all type flows can saturate, with the exception of a few ones that need to track all their types, e.g., AllInstantiated, AllSynchronized, etc.

setSaturated

public void setSaturated()

Mark this flow as saturated. Each flow starts with isSaturated as false and once it is set to true it cannot be changed.

addState

public boolean addState(PointsToAnalysis bb,
                        TypeState add)

addState

public boolean addState(PointsToAnalysis bb,
                        TypeState add,
                        boolean postFlow)

addUse

public boolean addUse(PointsToAnalysis bb,
                      TypeFlow<?> use)

addUse

public boolean addUse(PointsToAnalysis bb,
                      TypeFlow<?> use,
                      boolean propagateTypeState)

notifyUseOfSaturation

protected void notifyUseOfSaturation(PointsToAnalysis bb,
                                     TypeFlow<?> use)

doAddUse

protected boolean doAddUse(PointsToAnalysis bb,
                           TypeFlow<?> use)

removeUse

public boolean removeUse(TypeFlow<?> use)

clearUses

public void clearUses()

getUses

public Collection<TypeFlow<?>> getUses()

addObserver

public void addObserver(PointsToAnalysis bb,
                        TypeFlow<?> observer)

Register object that will be notified when the state of this flow changes.

addObserver

public boolean addObserver(PointsToAnalysis bb,
                           TypeFlow<?> observer,
                           boolean triggerUpdate)

notifyObserverOfSaturation

protected void notifyObserverOfSaturation(PointsToAnalysis bb,
                                          TypeFlow<?> observer)

removeObserver

public boolean removeObserver(TypeFlow<?> observer)

clearObservers

public void clearObservers()

getObservers

public Collection<TypeFlow<?>> getObservers()

addObservee

public void addObservee(TypeFlow<?> observee)

getObservees

public Collection<TypeFlow<?>> getObservees()

clearObservees

public void clearObservees()

addInput

public void addInput(TypeFlow<?> input)

getInputs

public Collection<TypeFlow<?>> getInputs()

clearInputs

public void clearInputs()

filter

public TypeState filter(PointsToAnalysis bb,
                        TypeState newState)

declaredTypeFilter

public TypeState declaredTypeFilter(PointsToAnalysis bb,
                                    TypeState newState)

Filter type states using a flow's declared type. This is used when the type flow constraints are relaxed to make sure that only compatible types are flowing through certain flows, e.g., stored to fields or passed to parameters. When the type flow constraints are not relaxed incompatible types flowing through such flows will result in an analysis error.

declaredTypeFilter

public TypeState declaredTypeFilter(PointsToAnalysis bb,
                                    TypeState newState,
                                    boolean onlyWithRelaxedTypeFlowConstraints)

filterUncheckedInterface

public static AnalysisType filterUncheckedInterface(AnalysisType type)

In Java, interface types are not checked by the bytecode verifier. So even when, e.g., a method parameter has the declared type Comparable, any Object can be passed in. We therefore need to filter out interface types, as well as arrays of interface types, in many places where we use the declared type. Places where interface types need to be filtered: method parameters, method return values, and field loads (including unsafe memory loads). Places where interface types need not be filtered: array element loads (because all array stores have an array store check).

update

public void update(PointsToAnalysis bb)

onObservedUpdate

public void onObservedUpdate(PointsToAnalysis bb)

Notify the observer that the observed type flow state has changed.

onSaturated

protected void onSaturated(PointsToAnalysis bb)

Called when this type flow becomes saturated.

onSaturated

protected void onSaturated()

swapOut

protected void swapOut(PointsToAnalysis bb,
                       TypeFlow<?> newFlow)

This flow will swap itself out at all uses and observers.

swapAtUse

protected void swapAtUse(PointsToAnalysis bb,
                         TypeFlow<?> newFlow,
                         TypeFlow<?> use)

swapAtObserver

protected void swapAtObserver(PointsToAnalysis bb,
                              TypeFlow<?> newFlow,
                              TypeFlow<?> observer)

onInputSaturated

protected void onInputSaturated(PointsToAnalysis bb,
                                TypeFlow<?> input)

Notified by an input that it is saturated and it will stop sending updates.

onObservedSaturated

public void onObservedSaturated(PointsToAnalysis bb,
                                TypeFlow<?> observed)

Notified by an observed flow that it is saturated.

replaceObservedWith

public void replaceObservedWith(PointsToAnalysis bb,
                                AnalysisType newObservedType)

When an "observed -> observer" link is updated the observer needs to be notified as well so it can update its internal reference. This link update can happen when the observed becomes saturated and it will stop sending updates. It is then usually replaced with a conservative approximation, e.g., the flow of the receiver type for a special invoke operation or of the field declaring class for a field access operation. By default the observers don't use the null state of the observed, therefore the non-null type flow is used. The overloaded TypeFlow.replacedObservedWith(PointsToAnalysis, TypeFlow) can be used for replacing the observed with a custom type flow.

replacedObservedWith

public void replacedObservedWith(PointsToAnalysis bb,
                                 TypeFlow<?> newObservedFlow)

setObserved

protected void setObserved(TypeFlow<?> newObservedFlow)

Set the type flow that this flow is observing.

formatSource

public String formatSource()

format

public String format(boolean withState,
                     boolean withSource)

toString

public String toString()

Overrides:

toString in class Object

equals

public final boolean equals(Object other)

Overrides:

equals in class Object

hashCode

public final int hashCode()

Overrides:

hashCode in class Object