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, 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(BigBang bb, TypeFlow<?> observer) Register object that will be notified when the state of this flow changes.
boolean	addOriginalObserver(BigBang bb, TypeFlow<?> observer) Adds an observer, if not already present, without triggering update.
boolean	addOriginalUse(BigBang bb, TypeFlow<?> use) Adds a use, if not already present, without propagating state.
boolean	addState(BigBang bb, TypeState add)
boolean	addState(BigBang bb, TypeState add, boolean postFlow)
boolean	addUse(BigBang 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(BigBang bb, MethodFlowsGraph methodFlows) By default a type flow is not cloneable.
TypeState	declaredTypeFilter(BigBang bb, TypeState newState) Filter type states using a flow's declared type.
protected boolean	doAddUse(BigBang bb, TypeFlow<?> use, boolean registerInput)
boolean	equals(Object other)
TypeState	filter(BigBang bb, TypeState newState)
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(BigBang bb) Initialization code for some clone corner case type flows.
boolean	isAllInstantiated()
boolean	isClone()
boolean	isCloseToAllInstantiated(BigBang bb)
boolean	isSaturated() Return true if this flow is saturated.
boolean	isUsedAsAParameter()
boolean	isUsedAsAReceiver()
AnalysisMethod	method()
protected void	notifyObservers(BigBang bb) Let the observers know that the state has changed.
protected void	onInputSaturated(BigBang bb, TypeFlow<?> input) Notified by an input that it is saturated and it will stop sending updates.
void	onObservedSaturated(BigBang bb, TypeFlow<?> observed) Notified by an observed flow that it is saturated.
void	onObservedUpdate(BigBang bb) Notify the observer that the observed type flow state has changed.
protected void	onSaturated(BigBang bb) Called when this type flow becomes saturated.
TypeFlow<?>	receiver() Some flow have a reciver (e.g., loads, store and invokes).
boolean	removeInput(TypeFlow<?> input)
boolean	removeObservee(TypeFlow<?> observee)
boolean	removeObserver(TypeFlow<?> observer)
boolean	removeUse(TypeFlow<?> use)
void	replacedObservedWith(BigBang bb, TypeFlow<?> newObservedFlow)
void	replaceObservedWith(BigBang 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(BigBang bb, TypeState state)
void	setUsedAsAParameter(boolean usedAsAParameter)
void	setUsedAsAReceiver(boolean usedAsAReceiver)
protected void	swapOut(BigBang bb, TypeFlow<?> newFlow) This flow will swap itself out at all uses and observers.
String	toString()
void	update(BigBang 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,
                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(BigBang bb,
                        MethodFlowsGraph methodFlows)

By default a type flow is not cloneable.

Parameters:

bb -

methodFlows -

initClone

public void initClone(BigBang 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 flow have a reciver (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()

isCloseToAllInstantiated

public boolean isCloseToAllInstantiated(BigBang bb)

setState

public void setState(BigBang 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(BigBang bb,
                        TypeState add)

addState

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

addOriginalUse

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

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

addUse

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

doAddUse

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

removeUse

public boolean removeUse(TypeFlow<?> use)

getUses

public Collection<TypeFlow<?>> getUses()

addOriginalObserver

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

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

addObserver

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

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

removeObserver

public boolean removeObserver(TypeFlow<?> observer)

getObservers

public Collection<TypeFlow<?>> getObservers()

notifyObservers

protected void notifyObservers(BigBang 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(BigBang bb,
                        TypeState newState)

declaredTypeFilter

public TypeState declaredTypeFilter(BigBang 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 constratints are not relaxed incompatible types flowing through such flows will result in an analysis error.

update

public void update(BigBang bb)

onObservedUpdate

public void onObservedUpdate(BigBang bb)

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

onSaturated

protected void onSaturated(BigBang bb)

Called when this type flow becomes saturated.

swapOut

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

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

onInputSaturated

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

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

onObservedSaturated

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

Notified by an observed flow that it is saturated.

replaceObservedWith

public void replaceObservedWith(BigBang 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(BigBang, TypeFlow) can be used for replacing the observed with a custom type flow.

replacedObservedWith

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

setObserved

protected void setObserved(TypeFlow<?> newObservedFlow)

Set the type flow that this flow is observing.

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