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, DynamicNewInstanceTypeFlow, FieldFilterTypeFlow, FieldTypeFlow, FilterTypeFlow, FormalParamTypeFlow, FormalReturnTypeFlow, FrozenFieldFilterTypeFlow, InitialParamTypeFlow, InstanceOfTypeFlow, InvokeTypeFlow, MergeTypeFlow, MethodTypeFlow, MonitorEnterTypeFlow, NullCheckTypeFlow, OffsetLoadTypeFlow, OffsetStoreTypeFlow, ProxyTypeFlow, SourceTypeFlowBase, UnsafeWriteSinkTypeFlow

public abstract class TypeFlow<T>
extends Object

Field Summary

Fields

Modifier and Type	Field and Description
protected AnalysisContext	context
protected AnalysisType	declaredType
protected MethodFlowsGraph	graphRef
protected int	id
boolean	inQueue
protected static AtomicInteger	nextId
protected T	source
protected boolean	usedAsAParameter True if this flow is passed as a parameter to a call.
protected boolean	usedAsAReceiver True if this flow is the receiver of a virtual call.

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(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	addOriginalObserver(PointsToAnalysis bb, TypeFlow<?> observer) Adds an observer, if not already present, without triggering update.
boolean	addOriginalUse(PointsToAnalysis bb, TypeFlow<?> use) Adds a use, if not already present, without propagating state.
boolean	addState(PointsToAnalysis bb, TypeState add)
boolean	addState(PointsToAnalysis bb, TypeState add, boolean postFlow)
boolean	addUse(PointsToAnalysis bb, TypeFlow<?> use)
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.
AnalysisContext	context()
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.
protected boolean	doAddUse(PointsToAnalysis bb, TypeFlow<?> use, boolean registerInput)
boolean	equals(Object other)
TypeState	filter(PointsToAnalysis bb, TypeState newState)
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	initClone(PointsToAnalysis bb) Initialization code for some clone corner case type flows.
boolean	isAllInstantiated()
boolean	isClone()
boolean	isSaturated() Return true if this flow is saturated.
boolean	isUsedAsAParameter()
boolean	isUsedAsAReceiver()
AnalysisMethod	method()
protected void	notifyObserverOfSaturation(PointsToAnalysis bb, TypeFlow<?> observer)
protected void	notifyObservers(PointsToAnalysis bb) Let the observers know that the state has changed.
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(PointsToAnalysis bb) Called when this type flow becomes saturated.
TypeFlow<?>	receiver() Some flows have a receiver (e.g., loads, store and invokes).
boolean	removeInput(TypeFlow<?> input)
boolean	removeObservee(TypeFlow<?> observee)
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)
void	setUsedAsAParameter(boolean usedAsAParameter)
void	setUsedAsAReceiver(boolean usedAsAReceiver)
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, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

nextId

protected static final AtomicInteger nextId

id

protected final int id

source

protected final T source

declaredType

protected final AnalysisType declaredType

graphRef

protected final MethodFlowsGraph graphRef

context

protected final AnalysisContext context

usedAsAParameter

protected boolean usedAsAParameter

True if this flow is passed as a parameter to a call.

usedAsAReceiver

protected boolean usedAsAReceiver

True if this flow is the receiver of a virtual call. If true, usedAsAParameter is also true.

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

Method Detail

copy

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

By default a type flow is not cloneable.

Parameters:

bb -

methodFlows -

initClone

public void initClone(PointsToAnalysis bb)

Initialization code for some clone corner case type flows.

Parameters:

bb -

setUsedAsAParameter

public void setUsedAsAParameter(boolean usedAsAParameter)

isUsedAsAParameter

public boolean isUsedAsAParameter()

setUsedAsAReceiver

public void setUsedAsAReceiver(boolean usedAsAReceiver)

isUsedAsAReceiver

public boolean isUsedAsAReceiver()

receiver

public TypeFlow<?> receiver()

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

id

public int id()

context

public AnalysisContext context()

graphRef

public MethodFlowsGraph graphRef()

method

public AnalysisMethod method()

getSource

public T getSource()

isClone

public boolean isClone()

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()

isSaturated

public boolean isSaturated()

Return true if this flow is saturated. When an observer becomes saturated it doesn't immediately remove itslef 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 cannnot be changed.

addState

public boolean addState(PointsToAnalysis bb,
                        TypeState add)

addState

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

addOriginalUse

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

Adds a use, if not already present, without propagating state.

addUse

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

notifyUseOfSaturation

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

doAddUse

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

removeUse

public boolean removeUse(TypeFlow<?> use)

getUses

public Collection<TypeFlow<?>> getUses()

addOriginalObserver

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

Adds an observer, if not already present, without triggering update.

addObserver

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

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

notifyObserverOfSaturation

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

removeObserver

public boolean removeObserver(TypeFlow<?> observer)

getObservers

public Collection<TypeFlow<?>> getObservers()

notifyObservers

protected void notifyObservers(PointsToAnalysis bb)

Let the observers know that the state has changed.

addObservee

public void addObservee(TypeFlow<?> observee)

getObservees

public Collection<TypeFlow<?>> getObservees()

removeObservee

public boolean removeObservee(TypeFlow<?> observee)

addInput

public void addInput(TypeFlow<?> input)

getInputs

public Collection<TypeFlow<?>> getInputs()

removeInput

public boolean removeInput(TypeFlow<?> input)

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.

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.

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