How to use

HostVM

in

com.oracle.graal.pointsto.api

public void registerAsInTypeCheck() {
  isInTypeCheck = true;
  universe.hostVM.checkForbidden(this, UsageKind.InTypeCheck);
}

private static void registerForeignCall(BigBang bb, ForeignCallDescriptor foreignCallDescriptor) {
  Optional<AnalysisMethod> targetMethod = bb.getHostVM().handleForeignCall(foreignCallDescriptor, bb.getProviders().getForeignCalls());
  targetMethod.ifPresent(analysisMethod -> {
    bb.addRootMethod(analysisMethod);
  });
}

@Override
public final boolean isInitialized() {
  return universe.hostVM.isInitialized(this);
}

if (fieldValue.getJavaKind() == JavaKind.Object && bb.getHostVM().isRelocatedPointer(bb.getSnippetReflectionProvider().asObject(Object.class, fieldValue))) {
  forRelocatedPointerFieldValue(receiver, field, fieldValue);
} else if (fieldValue.isNull()) {

this.debug = DebugContext.create(options, debugHandlerFactories);
this.hostVM = hostVM;
String imageName = hostVM.getImageName();
this.typeFlowTimer = new Timer(imageName, "(typeflow)", false);
this.checkObjectsTimer = new Timer(imageName, "(objects)", false);

} else {
  executorService.execute(() -> {
    bb.getHostVM().installInThread(vmConfig);
    long startTime = 0L;
    if (timing != null) {
      thrown = x;
    } finally {
      bb.getHostVM().clearInThread();
      if (timing != null) {
        long taskTime = System.nanoTime() - startTime;

public ContextSensitiveAnalysisObject(AnalysisUniverse universe, AnalysisType type, AnalysisObjectKind kind) {
  super(universe, type, kind);
  assert PointstoOptions.AllocationSiteSensitiveHeap.getValue(universe.hostVM().options());
}

public void init(Timing newTiming) {
  assert isSequential() || !executorService.hasQueuedSubmissions();
  assert Thread.currentThread() == mainThread;
  timing = newTiming;
  setState(State.BEFORE_START);
  postedOperations.reset();
  completedOperations.reset();
  postedBeforeStart.clear();
  vmConfig = bb.getHostVM().getConfiguration();
}

        .withUnresolvedIsError(PointstoOptions.UnresolvedIsError.getValue(bb.getOptions()))
        .withNodeSourcePosition(true).withBytecodeExceptionMode(BytecodeExceptionMode.CheckAll);
bb.getHostVM().createGraphBuilderPhase(bb.getProviders(), config, OptimisticOptimizations.NONE, null).apply(graph);

/**
 * Intercept {@link Word} types. They are boxed objects in the hosted world, but primitive
 * values in the runtime world.
 */
private JavaConstant interceptWordType(AnalysisField field, JavaConstant value) {
  if (value.getJavaKind() == JavaKind.Object) {
    Object originalObject = universe.getSnippetReflection().asObject(Object.class, value);
    if (universe.hostVM().isRelocatedPointer(originalObject)) {
      /*
       * Such pointers are subject to relocation therefore we don't know their values yet.
       * Therefore there should not be a relocated pointer constant in a function which is
       * compiled. RelocatedPointers are only allowed in non-constant fields. The caller
       * of readValue is responsible of handling the returned value correctly.
       */
      return value;
    } else if (originalObject instanceof WordBase) {
      return JavaConstant.forIntegerKind(universe.getWordKind(), ((WordBase) originalObject).rawValue());
    } else if (originalObject == null && field.getType().isWordType()) {
      return JavaConstant.forIntegerKind(universe.getWordKind(), 0);
    }
  }
  return value;
}

@SuppressWarnings("try")
public void finish(DebugContext debug) {
  try {
    String imageName = universe.getBigBang().getHostVM().getImageName();
    try (StopTimer t = new Timer(imageName, "(parse)").start()) {
      parseAll();

public AnalysisField(AnalysisUniverse universe, ResolvedJavaField wrappedField) {
  assert !wrappedField.isInternal();
  this.position = -1;
  this.isUnsafeAccessed = new AtomicBoolean();
  this.unsafeFrozenTypeState = new AtomicBoolean();
  this.wrapped = wrappedField;
  this.id = universe.nextFieldId.getAndIncrement();
  readBy = PointstoOptions.TrackAccessChain.getValue(universe.hostVM().options()) ? new ConcurrentHashMap<>() : null;
  writtenBy = new ConcurrentHashMap<>();
  declaringClass = universe.lookup(wrappedField.getDeclaringClass());
  fieldType = getDeclaredType(universe, wrappedField);
  isUsedInComparison = false;
  if (this.isStatic()) {
    this.canBeNull = false;
    this.staticFieldFlow = new FieldTypeFlow(this, getType());
    this.initialInstanceFieldFlow = null;
  } else {
    this.canBeNull = true;
    this.instanceFieldFlow = new FieldSinkTypeFlow(this, getType());
    this.initialInstanceFieldFlow = new FieldTypeFlow(this, getType());
  }
}

public void registerAsInHeap() {
  assert isArray() || (isInstanceClass() && !Modifier.isAbstract(getModifiers()));
  isInHeap = true;
  universe.hostVM.checkForbidden(this, UsageKind.InHeap);
}

this.id = universe.nextMethodId.getAndIncrement();
if (PointstoOptions.TrackAccessChain.getValue(universe.hostVM().options())) {
  startTrackInvocations();
typeFlow = new MethodTypeFlow(universe.hostVM().options(), this);

/**
 * @param node For future use and debugging
 */
public void registerAsAllocated(Node node) {
  assert isArray() || (isInstanceClass() && !Modifier.isAbstract(getModifiers())) : this;
  if (!isAllocated) {
    isAllocated = true;
  }
  universe.hostVM.checkForbidden(this, UsageKind.Allocated);
}