How to use

materialize

method

in

com.oracle.truffle.api.frame.VirtualFrame

@Override
protected void onReturnExceptional(VirtualFrame frame, Throwable exception) {
  if (stepping.get()) {
    doStepAfter(frame.materialize(), exception);
  }
}

@Override
public void onReturnValue(VirtualFrame frame, Object result) {
  if (stepping.get()) {
    doReturn(frame.materialize(), result);
  }
}

@Override
protected Object onUnwind(VirtualFrame frame, Object info) {
  if (stepping.get()) {
    return doUnwind(frame.materialize());
  } else {
    return null;
  }
}

@Override
protected void onEnter(VirtualFrame frame) {
  if (stepping.get()) {
    doStepBefore(frame.materialize());
  }
}

@Override
public void onReturnValue(VirtualFrame frame, Object result) {
  if (stepping.get()) {
    doReturn(frame.materialize(), result);
  }
}

@Override
protected void onReturnValue(VirtualFrame frame, Object result) {
  if (stepping.get()) {
    doStepAfter(frame.materialize(), result);
  }
}

@Override
public void onReturnExceptional(VirtualFrame frame, Throwable exception) {
  if (stepping.get()) {
    doReturn(frame.materialize(), null);
  }
}

@Override
protected void onEnter(VirtualFrame frame) {
  if (stepping.get()) {
    doStepBefore(frame.materialize());
  }
}

@Override
protected void onReturnExceptional(VirtualFrame frame, Throwable exception) {
  if (stepping.get()) {
    doStepAfter(frame.materialize(), exception);
  }
}

private MaterializedFrame initGlobalFrame() {
  VirtualFrame frame = Truffle.getRuntime().createVirtualFrame(null,
      this.globalFrameDescriptor);
  addGlobalFunctions(frame);
  return frame.materialize();
}

@Specialization(contains = { "getScopedFunction" })
public Object getMumblerFunction(VirtualFrame virtualFrame) {
  MumblerFunction function = this.getFunction();
  function.setLexicalScope(virtualFrame.materialize());
  return function;
}

@Override
protected Object onUnwind(VirtualFrame frame, Object info) {
  Object ret = super.onUnwind(frame, info);
  if (ret != null) {
    return ret;
  }
  if (stepping.get()) {
    return doUnwind(frame.materialize());
  } else {
    return null;
  }
}

@Override
protected void onReturnValue(VirtualFrame frame, Object result) {
  if (stepping.get()) {
    Object newResult = doStepAfter(frame.materialize(), result);
    if (newResult != result) {
      CompilerDirectives.transferToInterpreter();
      throw getContext().createUnwind(new ChangedReturnInfo(newResult));
    }
  }
}

public void enter(Node node, VirtualFrame vFrame) {
  this.probe.checkProbeUnchanged();
  final SyntaxTagTrap beforeTagTrap = probe.getBeforeTrap();
  if (beforeTagTrap != null) {
    beforeTagTrap.tagTrappedAt(((WrapperNode) this.getParent()).getChild(), vFrame.materialize());
  }
  if (firstInstrumentNode != null) {
    firstInstrumentNode.enter(node, vFrame);
  }
}

public void returnExceptional(Node node, VirtualFrame vFrame, Exception exception) {
  this.probe.checkProbeUnchanged();
  if (firstInstrumentNode != null) {
    firstInstrumentNode.returnExceptional(node, vFrame, exception);
  }
  final SyntaxTagTrap afterTagTrap = probe.getAfterTrap();
  if (afterTagTrap != null) {
    afterTagTrap.tagTrappedAt(((WrapperNode) this.getParent()).getChild(), vFrame.materialize());
  }
}

public void returnVoid(Node node, VirtualFrame vFrame) {
  this.probe.checkProbeUnchanged();
  if (firstInstrumentNode != null) {
    firstInstrumentNode.returnVoid(node, vFrame);
  }
  final SyntaxTagTrap afterTagTrap = probe.getAfterTrap();
  if (afterTagTrap != null) {
    afterTagTrap.tagTrappedAt(((WrapperNode) this.getParent()).getChild(), vFrame.materialize());
  }
}

public void returnValue(Node node, VirtualFrame vFrame, Object result) {
  this.probe.checkProbeUnchanged();
  if (firstInstrumentNode != null) {
    firstInstrumentNode.returnValue(node, vFrame, result);
  }
  final SyntaxTagTrap afterTagTrap = probe.getAfterTrap();
  if (afterTagTrap != null) {
    afterTagTrap.tagTrappedAt(((WrapperNode) this.getParent()).getChild(), vFrame.materialize());
  }
}

boolean executeBreakCondition(VirtualFrame frame, DebuggerSession[] sessions) {
  if ((conditionSnippet == null && conditionCallNode == null) || !conditionUnchanged.isValid()) {
    CompilerDirectives.transferToInterpreterAndInvalidate();
    initializeConditional(frame.materialize());
  }
  Object result;
  try {
    suspensionEnabledNode.execute(false, sessions);
    if (conditionSnippet != null) {
      result = conditionSnippet.execute(frame);
    } else {
      result = conditionCallNode.call(EMPTY_ARRAY);
    }
  } finally {
    suspensionEnabledNode.execute(true, sessions);
  }
  if (!(result instanceof Boolean)) {
    CompilerDirectives.transferToInterpreter();
    throw new IllegalArgumentException("Unsupported return type " + result + " in condition.");
  }
  return (Boolean) result;
}

boolean executeBreakCondition(VirtualFrame frame, DebuggerSession[] sessions) {
  if ((conditionSnippet == null && conditionCallNode == null) || !conditionUnchanged.isValid()) {
    CompilerDirectives.transferToInterpreterAndInvalidate();
    initializeConditional(frame.materialize());
  }
  Object result;
  try {
    suspensionEnabledNode.execute(false, sessions);
    if (conditionSnippet != null) {
      result = conditionSnippet.execute(frame);
    } else {
      result = conditionCallNode.call(EMPTY_ARRAY);
    }
  } finally {
    suspensionEnabledNode.execute(true, sessions);
  }
  if (!(result instanceof Boolean)) {
    CompilerDirectives.transferToInterpreter();
    throw new IllegalArgumentException("Unsupported return type " + result + " in condition.");
  }
  return (Boolean) result;
}

breakpoint.doBreak(this, sessions, frame.materialize(), onEnter, result, conditionError);