com.oracle.graal.pointsto

Class BigBang

java.lang.Object

com.oracle.graal.pointsto.BigBang

public abstract class BigBang
extends Object

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected class	BigBang.AnalysisTiming
protected static class	BigBang.BucketTiming
static class	BigBang.ConstantObjectsProfiler
static interface	BigBang.TypeFlowRunnable

Field Summary

Fields

Modifier and Type	Field and Description
Timer	checkObjectsTimer
protected HostVM	hostVM
protected AnalysisMetaAccess	metaAccess
AtomicLong	numParsedGraphs
protected boolean	reportAnalysisStatistics
protected boolean	trackTypeFlowInputs
Timer	typeFlowTimer
protected AnalysisUniverse	universe

Constructor Summary

Constructors

Constructor and Description
BigBang(org.graalvm.compiler.options.OptionValues options, AnalysisUniverse universe, HostedProviders providers, HostVM hostVM, ForkJoinPool executorService, UnsupportedFeatures unsupportedFeatures)

Method Summary

Modifier and Type	Method and Description
abstract boolean	addRoot(jdk.vm.ci.meta.JavaConstant constant, Object root) Associates a JavaConstant with a root.
AnalysisMethod	addRootMethod(AnalysisMethod aMethod)
AnalysisMethod	addRootMethod(Executable method)
AnalysisType	addSystemClass(Class<?> clazz, boolean addFields, boolean addArrayClass)
AnalysisType	addSystemField(Class<?> clazz, String fieldName)
void	addSystemMethod(Class<?> clazz, String methodName, Class<?>... parameterTypes)
AnalysisType	addSystemStaticField(Class<?> clazz, String fieldName)
AnalysisPolicy	analysisPolicy()
protected void	checkObjectGraph(ObjectScanner objectScanner) Traverses the object graph to discover references to new types.
void	checkUnsupportedSynchronization(AnalysisMethod method, int bci, AnalysisType aType) Check if the type is allowed to be used for synchronization.
void	checkUserLimitations()
void	cleanupAfterAnalysis()
AnalysisContextPolicy<AnalysisContext>	contextPolicy()
static ForkJoinPool	createExecutor(org.graalvm.compiler.debug.DebugContext debug, int numberOfThreads)
MethodTypeFlowBuilder	createMethodTypeFlowBuilder(BigBang bb, MethodTypeFlow methodFlow)
boolean	doTypeflow()
boolean	executorIsStarted()
boolean	finish() Performs the analysis.
void	forceUnsafeUpdate(AnalysisField field) Force update of the unsafe loads and unsafe store type flows when a field is registered as unsafe accessed 'on the fly', i.e., during the analysis.
AnalysisType	forClass(Class<?> clazz)
AnalysisType	forClass(String className)
TypeFlow<?>	getAllInstantiatedTypeFlow()
TypeFlow<?>	getAllSynchronizedTypeFlow()
TypeState	getAllSynchronizedTypeState()
org.graalvm.compiler.core.common.spi.ConstantFieldProvider	getConstantFieldProvider()
jdk.vm.ci.meta.ConstantReflectionProvider	getConstantReflectionProvider()
org.graalvm.compiler.debug.DebugContext	getDebug()
List<org.graalvm.compiler.debug.DebugHandlersFactory>	getDebugHandlerFactories()
CompletionExecutor	getExecutor()
AnalysisType	getGraalNodeListType()
AnalysisType	getGraalNodeType()
HostVM	getHostVM()
AnalysisMetaAccess	getMetaAccess()
AnalysisType	getObjectArrayType()
AnalysisType	getObjectType()
org.graalvm.compiler.options.OptionValues	getOptions()
HostedProviders	getProviders()
org.graalvm.compiler.nodes.spi.Replacements	getReplacements()
abstract Object	getRoot(jdk.vm.ci.meta.JavaConstant constant) Retrieves a root associated with a JavaConstant.
org.graalvm.compiler.api.replacements.SnippetReflectionProvider	getSnippetReflectionProvider()
AnalysisType	getThreadType()
AnalysisType	getThrowableType()
AnalysisUniverse	getUniverse()
TypeFlow<?>	getUnknownTypeFlow()
UnsupportedFeatures	getUnsupportedFeatures()
boolean	isCallAllowed(BigBang bb, AnalysisMethod caller, AnalysisMethod target, org.graalvm.compiler.graph.NodeSourcePosition srcPosition) You can blacklist certain callees here.
abstract boolean	isValidClassLoader(Object valueObj)
void	postFlow(TypeFlow<?> operation)
void	postTask(CompletionExecutor.DebugContextRunnable task)
void	registerUnsafeLoad(OffsetLoadTypeFlow.AbstractUnsafeLoadTypeFlow unsafeLoad)
void	registerUnsafeStore(OffsetStoreTypeFlow.AbstractUnsafeStoreTypeFlow unsafeStore)
boolean	reportAnalysisStatistics()
void	reportIllegalUnknownUse(AnalysisMethod method, org.graalvm.compiler.graph.Node source, String message)
boolean	trackConcreteAnalysisObjects(AnalysisType type) By default the analysis tracks all concrete objects for all types (if the analysis is context sensitive).
boolean	trackTypeFlowInputs()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

universe

protected final AnalysisUniverse universe

metaAccess

protected final AnalysisMetaAccess metaAccess

hostVM

protected final HostVM hostVM

trackTypeFlowInputs

protected final boolean trackTypeFlowInputs

reportAnalysisStatistics

protected final boolean reportAnalysisStatistics

numParsedGraphs

public final AtomicLong numParsedGraphs

typeFlowTimer

public final Timer typeFlowTimer

checkObjectsTimer

public final Timer checkObjectsTimer

Constructor Detail

BigBang

public BigBang(org.graalvm.compiler.options.OptionValues options,
               AnalysisUniverse universe,
               HostedProviders providers,
               HostVM hostVM,
               ForkJoinPool executorService,
               UnsupportedFeatures unsupportedFeatures)

Method Detail

trackTypeFlowInputs

public boolean trackTypeFlowInputs()

reportAnalysisStatistics

public boolean reportAnalysisStatistics()

getOptions

public org.graalvm.compiler.options.OptionValues getOptions()

getDebugHandlerFactories

public List<org.graalvm.compiler.debug.DebugHandlersFactory> getDebugHandlerFactories()

getDebug

public org.graalvm.compiler.debug.DebugContext getDebug()

createMethodTypeFlowBuilder

public MethodTypeFlowBuilder createMethodTypeFlowBuilder(BigBang bb,
                                                         MethodTypeFlow methodFlow)

addRoot

public abstract boolean addRoot(jdk.vm.ci.meta.JavaConstant constant,
                                Object root)

Associates a JavaConstant with a root.

getRoot

public abstract Object getRoot(jdk.vm.ci.meta.JavaConstant constant)

Retrieves a root associated with a JavaConstant.

registerUnsafeLoad

public void registerUnsafeLoad(OffsetLoadTypeFlow.AbstractUnsafeLoadTypeFlow unsafeLoad)

registerUnsafeStore

public void registerUnsafeStore(OffsetStoreTypeFlow.AbstractUnsafeStoreTypeFlow unsafeStore)

reportIllegalUnknownUse

public void reportIllegalUnknownUse(AnalysisMethod method,
                                    org.graalvm.compiler.graph.Node source,
                                    String message)

forceUnsafeUpdate

public void forceUnsafeUpdate(AnalysisField field)

Force update of the unsafe loads and unsafe store type flows when a field is registered as unsafe accessed 'on the fly', i.e., during the analysis.

Parameters:

field - the newly unsafe registered field. We use its declaring type to filter the unsafe access flows that need to be updated.

trackConcreteAnalysisObjects

public boolean trackConcreteAnalysisObjects(AnalysisType type)

By default the analysis tracks all concrete objects for all types (if the analysis is context sensitive). However, the client of the analysis can opt that some types should be analyzed without tracking concrete objects even when the analysis is context sensitive.

isCallAllowed

public boolean isCallAllowed(BigBang bb,
                             AnalysisMethod caller,
                             AnalysisMethod target,
                             org.graalvm.compiler.graph.NodeSourcePosition srcPosition)

You can blacklist certain callees here.

cleanupAfterAnalysis

public void cleanupAfterAnalysis()

analysisPolicy

public AnalysisPolicy analysisPolicy()

contextPolicy

public AnalysisContextPolicy<AnalysisContext> contextPolicy()

getUniverse

public AnalysisUniverse getUniverse()

getProviders

public HostedProviders getProviders()

getMetaAccess

public AnalysisMetaAccess getMetaAccess()

getReplacements

public org.graalvm.compiler.nodes.spi.Replacements getReplacements()

getUnsupportedFeatures

public UnsupportedFeatures getUnsupportedFeatures()

getObjectType

public AnalysisType getObjectType()

getObjectArrayType

public AnalysisType getObjectArrayType()

getGraalNodeType

public AnalysisType getGraalNodeType()

getGraalNodeListType

public AnalysisType getGraalNodeListType()

getThrowableType

public AnalysisType getThrowableType()

getThreadType

public AnalysisType getThreadType()

forClass

public AnalysisType forClass(Class<?> clazz)

forClass

public AnalysisType forClass(String className)

getAllInstantiatedTypeFlow

public TypeFlow<?> getAllInstantiatedTypeFlow()

getUnknownTypeFlow

public TypeFlow<?> getUnknownTypeFlow()

getAllSynchronizedTypeFlow

public TypeFlow<?> getAllSynchronizedTypeFlow()

getAllSynchronizedTypeState

public TypeState getAllSynchronizedTypeState()

executorIsStarted

public boolean executorIsStarted()

addRootMethod

public AnalysisMethod addRootMethod(Executable method)

addRootMethod

public AnalysisMethod addRootMethod(AnalysisMethod aMethod)

addSystemClass

public AnalysisType addSystemClass(Class<?> clazz,
                                   boolean addFields,
                                   boolean addArrayClass)

addSystemField

public AnalysisType addSystemField(Class<?> clazz,
                                   String fieldName)

addSystemStaticField

public AnalysisType addSystemStaticField(Class<?> clazz,
                                         String fieldName)

addSystemMethod

public void addSystemMethod(Class<?> clazz,
                            String methodName,
                            Class<?>... parameterTypes)

getSnippetReflectionProvider

public final org.graalvm.compiler.api.replacements.SnippetReflectionProvider getSnippetReflectionProvider()

getConstantReflectionProvider

public final jdk.vm.ci.meta.ConstantReflectionProvider getConstantReflectionProvider()

getConstantFieldProvider

public org.graalvm.compiler.core.common.spi.ConstantFieldProvider getConstantFieldProvider()

getExecutor

public CompletionExecutor getExecutor()

isValidClassLoader

public abstract boolean isValidClassLoader(Object valueObj)

checkUserLimitations

public void checkUserLimitations()

postFlow

public void postFlow(TypeFlow<?> operation)

postTask

public void postTask(CompletionExecutor.DebugContextRunnable task)

finish

public boolean finish()
               throws InterruptedException

Performs the analysis.

Returns:

Returns true if any changes are made, i.e. if any type flows are updated

Throws:

InterruptedException

doTypeflow

public boolean doTypeflow()
                   throws InterruptedException

Throws:

InterruptedException

checkUnsupportedSynchronization

public void checkUnsupportedSynchronization(AnalysisMethod method,
                                            int bci,
                                            AnalysisType aType)

Check if the type is allowed to be used for synchronization.

Parameters:

method - - the method location of the synchronization

bci - - the bci location of the synchronization

aType - - the type that is synchronized on

checkObjectGraph

protected void checkObjectGraph(ObjectScanner objectScanner)

Traverses the object graph to discover references to new types.

Parameters:

objectScanner -

getHostVM

public HostVM getHostVM()

createExecutor

public static ForkJoinPool createExecutor(org.graalvm.compiler.debug.DebugContext debug,
                                          int numberOfThreads)