Java CompilerDirectives.transferToInterpreter方法代码示例

import com.oracle.truffle.api.CompilerDirectives; //导入方法依赖的package包/类
@Specialization
public final Object write(final VirtualFrame frame, final SChannelOutput out,
    final Object val) {
  if (!isVal.executeEvaluated(val)) {
    KernelObj.signalException("signalNotAValueWith:", val);
  }
  try {
    out.writeAndSuspendReader(val, afterRead.executeShouldHalt());
    if (out.shouldBreakAfterWrite()) {
      haltNode.executeEvaluated(frame, val);
    }
  } catch (InterruptedException e) {
    CompilerDirectives.transferToInterpreter();
    throw new RuntimeException(e);
  }
  return val;
}
 

import com.oracle.truffle.api.CompilerDirectives; //导入方法依赖的package包/类
@Override
public Object executeGeneric(final VirtualFrame frame) {
  Object result = expression.executeGeneric(frame);

  MaterializedFrame ctx = determineContext(frame);
  FrameOnStackMarker marker = getMarkerFromContext(ctx);

  if (marker.isOnStack()) {
    throw new ReturnException(result, marker);
  } else {
    CompilerDirectives.transferToInterpreter();
    // TODO: this should never be a performance relevant path... do caching if necessary

    SBlock block = (SBlock) SArguments.rcvr(frame);
    Object self = SArguments.rcvr(ctx);

    // Lookup the invokable
    SInvokable invokable = (SInvokable) Types.getClassOf(self).lookupMessage(
        escapedBlock, AccessModifier.PROTECTED);

    return invokable.invoke(call, new Object[] {self, block});
  }
}
 

import com.oracle.truffle.api.CompilerDirectives; //导入方法依赖的package包/类
@Specialization(contains = {"readLong", "readBoolean"})
protected Object readObject(VirtualFrame frame) {
    if (!frame.isObject(getSlot())) {
        CompilerDirectives.transferToInterpreter();
        Object result = frame.getValue(getSlot());
        frame.setObject(getSlot(), result);
        return result;
    }

    return FrameUtil.getObjectSafe(frame, getSlot());
}
 

import com.oracle.truffle.api.CompilerDirectives; //导入方法依赖的package包/类
@ExplodeLoop
public int executeSuccessorIndex(byte value) {
    for (int i = 0; i < matchers.length; i++) {
        if (matchers[i].match(value)) {
            return i;
        }
    }
    CompilerDirectives.transferToInterpreter();
    throw new IllegalStateException();
}
 

import com.oracle.truffle.api.CompilerDirectives; //导入方法依赖的package包/类
@ExplodeLoop(kind = ExplodeLoop.LoopExplosionKind.MERGE_EXPLODE)
protected boolean execute(byte[] inputString) {
    CompilerAsserts.compilationConstant(states.length);
    int ip = entry;
    int successor = -1;
    DFAStateNode curState = null;
    outer: while (true) {
        CompilerAsserts.partialEvaluationConstant(ip);
        CompilerAsserts.partialEvaluationConstant(states[ip]);
        curState = states[ip];
        if (curState.isFinalState()) {
            break;
        }
        if (!inputStringIterator.hasNext(inputString)) {
            break;
        }
        successor = curState.executeSuccessorIndex(inputStringIterator.next(inputString));
        int[] successors = curState.getSuccessors();
        for (int i = 0; i < successors.length; i++) {
            if (i == successor) {
                ip = successors[i];
                continue outer;
            }
        }
        CompilerDirectives.transferToInterpreter();
        throw new Error();
    }
    return curState.isFinalState();
}
 

import com.oracle.truffle.api.CompilerDirectives; //导入方法依赖的package包/类
@Override
public Object execute(VirtualFrame frame) {
    int x = (int) frame.getArguments()[0];
    if (x == 0) {
        CompilerDirectives.transferToInterpreter();
    } else {
        CompilerDirectives.transferToInterpreterAndInvalidate();
    }
    return null;
}
 

import com.oracle.truffle.api.CompilerDirectives; //导入方法依赖的package包/类
@Specialization
public boolean doAssert(boolean value, String message) {
    if (value) {
        CompilerDirectives.transferToInterpreter();
        throw new SLAssertionError(message == null ? "" : message);
    }
    return value;
}
 

import com.oracle.truffle.api.CompilerDirectives; //导入方法依赖的package包/类
@Specialization
public boolean doAssert(boolean value, String message) {
    if (!value) {
        CompilerDirectives.transferToInterpreter();
        throw new SLAssertionError(message == null ? "" : message);
    }
    return value;
}
 

import com.oracle.truffle.api.CompilerDirectives; //导入方法依赖的package包/类
@Specialization
@TruffleBoundary
public Object testTruffleBoundary() {
    CompilerAsserts.neverPartOfCompilation();
    CompilerAsserts.neverPartOfCompilation("Should never throw an exception when compiling.");
    CompilerAsserts.compilationConstant(nonConstantValue);
    CompilerDirectives.transferToInterpreter();
    CompilerDirectives.transferToInterpreterAndInvalidate();
    CompilerDirectives.bailout("Should not fail");
    if (CompilerDirectives.inCompiledCode()) {
        throw new AssertionError();
    }
    if (!CompilerDirectives.inInterpreter()) {
        throw new AssertionError();
    }
    try {
        int result = (int) CompilerDirectives.interpreterOnly(new Callable<Object>() {
            @Override
            public Object call() throws Exception {
                return 1;
            }
        });
        if (result != 1) {
            throw new AssertionError();
        }
    } catch (Exception e) {
        throw new AssertionError();
    }

    return SLNull.SINGLETON;
}
 

import com.oracle.truffle.api.CompilerDirectives; //导入方法依赖的package包/类
public static Object signalException(final String selector, final Object receiver) {
  SObjectWithClass rcvr = (SObjectWithClass) receiver;
  CompilerDirectives.transferToInterpreter();
  VM.thisMethodNeedsToBeOptimized("Should be optimized or on slowpath");

  // the value object was not constructed properly.
  SInvokable disp = (SInvokable) KernelObj.kernel.getSOMClass().lookupPrivate(
      Symbols.symbolFor(selector),
      KernelObj.kernel.getSOMClass().getMixinDefinition().getMixinId());
  return disp.invoke(new Object[] {KernelObj.kernel, rcvr.getSOMClass()});
}
 

import com.oracle.truffle.api.CompilerDirectives; //导入方法依赖的package包/类
@TruffleBoundary
private static Object signalNotAValue() {
  // TODO: this is a duplicated from IsValueCheckNode
  // TODO: don't think this is a complete solution, we need to do something else here
  // perhaps write the node, and then also use a send node...
  CompilerDirectives.transferToInterpreter();
  VM.thisMethodNeedsToBeOptimized("Should be optimized or on slowpath");

  // the value object was not constructed properly.
  SInvokable disp = (SInvokable) KernelObj.kernel.getSOMClass().lookupPrivate(
      Symbols.symbolFor("signalNotAValueWith:"),
      KernelObj.kernel.getSOMClass().getMixinDefinition().getMixinId());
  return disp.invoke(new Object[] {KernelObj.kernel, Classes.valueArrayClass});
}
 

import com.oracle.truffle.api.CompilerDirectives; //导入方法依赖的package包/类
@Specialization
public final Object doSBlock(final SBlock receiver, final Object firstArg,
    final Object secondArg, final Object thirdArg) {
  CompilerDirectives.transferToInterpreter();
  throw new RuntimeException(
      "This should never be called, because SOM Blocks have max. 2 arguments.");
}
 

import com.oracle.truffle.api.CompilerDirectives; //导入方法依赖的package包/类
@Specialization
public final Object doApply(final TruffleObject fun, final SArray args) {
  Node execNode = Message.createExecute((int) size.executeEvaluated(args)).createNode();

  Object[] arguments;
  if (args.isLongType()) {
    long[] arr = args.getLongStorage(storageType);
    arguments = new Object[arr.length];
    for (int i = 0; i < arr.length; i++) {
      arguments[i] = arr[i];
    }
  } else if (args.isObjectType()) {
    arguments = args.getObjectStorage(storageType);
  } else {
    CompilerDirectives.transferToInterpreter();
    throw new NotYetImplementedException();
  }

  try {
    Object result = ForeignAccess.sendExecute(execNode, fun, arguments);
    return convert.executeEvaluated(result);
  } catch (UnsupportedTypeException | ArityException
      | UnsupportedMessageException e) {
    CompilerDirectives.transferToInterpreter();
    throw new RuntimeException(e);
  }
}
 

import com.oracle.truffle.api.CompilerDirectives; //导入方法依赖的package包/类
@Specialization
public final Object read(final VirtualFrame frame, final SChannelInput in) {
  try {
    Object result = in.readAndSuspendWriter(afterWrite.executeShouldHalt());
    if (in.shouldBreakAfterRead()) {
      haltNode.executeEvaluated(frame, result);
    }
    return result;
  } catch (InterruptedException e) {
    CompilerDirectives.transferToInterpreter();
    throw new RuntimeException(e);
  }
}
 

import com.oracle.truffle.api.CompilerDirectives; //导入方法依赖的package包/类
@Specialization(guards = {"!rcvr.getObjectLayout().isValid()"})
public final Object updateObject(final SObject rcvr, final Object value) {
  // no invalidation, just moving to interpreter to avoid recursion in PE
  CompilerDirectives.transferToInterpreter();
  ObjectTransitionSafepoint.INSTANCE.transitionObject(rcvr);
  return executeEvaluated(rcvr, value);
}