/// <summary> /// Reset an existing value and re-execute the vm /// </summary> /// <param name="varName"></param> /// <param name="value"></param> public void SetValueAndExecute(string varName, int?value) { Executable exe = runtimeCore.DSExecutable; runtimeCore.Options.IsDeltaExecution = true; int nodesMarkedDirty = 0; bool wasSet = SetValue(varName, value, out nodesMarkedDirty); if (wasSet && nodesMarkedDirty > 0) { try { foreach (ProtoCore.DSASM.CodeBlock codeblock in exe.CodeBlocks) { ProtoCore.DSASM.StackFrame stackFrame = new ProtoCore.DSASM.StackFrame(runtimeCore.RuntimeMemory.GlobOffset); int locals = 0; // Comment Jun: Tell the new bounce stackframe that this is an implicit bounce // Register TX is used for this. stackFrame.TX = StackValue.BuildCallingConversion((int)CallingConvention.BounceType.Implicit); runtimeCore.CurrentExecutive.CurrentDSASMExec.Bounce( codeblock.codeBlockId, codeblock.instrStream.entrypoint, stackFrame, locals); } } catch { throw; } } }
public void Execute(ProtoCore.Core core, ProtoCore.Runtime.Context context, ProtoLanguage.CompileStateTracker compileState) { try { compileState.NotifyExecutionEvent(ProtoCore.ExecutionStateEventArgs.State.kExecutionBegin); foreach (ProtoCore.DSASM.CodeBlock codeblock in core.DSExecutable.CodeBlockList) { int locals = 0; // Comment Jun: // On first bounce, the stackframe depth is initialized to -1 in the Stackfame constructor. // Passing it to bounce() increments it so the first depth is always 0 ProtoCore.DSASM.StackFrame stackFrame = new ProtoCore.DSASM.StackFrame(core.GlobOffset); // Comment Jun: Tell the new bounce stackframe that this is an implicit bounce // Register TX is used for this. ProtoCore.DSASM.StackValue svCallConvention = ProtoCore.DSASM.StackUtils.BuildNode(ProtoCore.DSASM.AddressType.CallingConvention, (long)ProtoCore.DSASM.CallingConvention.BounceType.kImplicit); stackFrame.SetAt(ProtoCore.DSASM.StackFrame.AbsoluteIndex.kRegisterTX, svCallConvention); core.Bounce(codeblock.codeBlockId, codeblock.instrStream.entrypoint, context, stackFrame, locals, EventSink); } core.NotifyExecutionEvent(ProtoCore.ExecutionStateEventArgs.State.kExecutionEnd); } catch { core.NotifyExecutionEvent(ProtoCore.ExecutionStateEventArgs.State.kExecutionEnd); throw; } }
/// <summary> /// Reset an existing value and re-execute the vm /// </summary> /// <param name="varName"></param> /// <param name="value"></param> public void SetValueAndExecute(string varName, int? value) { core.Options.IsDeltaExecution = true; int nodesMarkedDirty = 0; bool wasSet = SetValue(varName, value, out nodesMarkedDirty); if (wasSet && nodesMarkedDirty > 0) { try { foreach (ProtoCore.DSASM.CodeBlock codeblock in core.CodeBlockList) { ProtoCore.Runtime.Context context = new ProtoCore.Runtime.Context(); ProtoCore.DSASM.StackFrame stackFrame = new ProtoCore.DSASM.StackFrame(core.GlobOffset); int locals = 0; // Comment Jun: Tell the new bounce stackframe that this is an implicit bounce // Register TX is used for this. StackValue svCallConvention = StackUtils.BuildNode(AddressType.CallingConvention, (long)ProtoCore.DSASM.CallingConvention.BounceType.kImplicit); stackFrame.SetAt(ProtoCore.DSASM.StackFrame.AbsoluteIndex.kRegisterTX, svCallConvention); core.Bounce(codeblock.codeBlockId, codeblock.instrStream.entrypoint, context, stackFrame, locals, new ProtoCore.DebugServices.ConsoleEventSink()); } } catch { throw; } } }
/// <summary> /// Reset an existing value and re-execute the vm /// </summary> /// <param name="varName"></param> /// <param name="value"></param> public void SetValueAndExecute(string varName, int? value) { Executable exe = runtimeCore.DSExecutable; runtimeCore.Options.IsDeltaExecution = true; int nodesMarkedDirty = 0; bool wasSet = SetValue(varName, value, out nodesMarkedDirty); if (wasSet && nodesMarkedDirty > 0) { try { foreach (ProtoCore.DSASM.CodeBlock codeblock in exe.CodeBlocks) { ProtoCore.DSASM.StackFrame stackFrame = new ProtoCore.DSASM.StackFrame(runtimeCore.RuntimeMemory.GlobOffset); int locals = 0; // Comment Jun: Tell the new bounce stackframe that this is an implicit bounce // Register TX is used for this. stackFrame.TX = StackValue.BuildCallingConversion((int)CallingConvention.BounceType.Implicit); runtimeCore.CurrentExecutive.CurrentDSASMExec.Bounce( codeblock.codeBlockId, codeblock.instrStream.entrypoint, stackFrame, locals); } } catch { throw; } } }
public override ProtoCore.DSASM.StackValue Execute(ProtoCore.Runtime.Context c, List <ProtoCore.DSASM.StackValue> formalParameters, ProtoCore.DSASM.StackFrame stackFrame, Core core) { ProtoCore.DSASM.Interpreter interpreter = new ProtoCore.DSASM.Interpreter(core, true); ProtoCore.DSASM.Executive oldDSASMExec = null; if (core.CurrentExecutive != null) { oldDSASMExec = core.CurrentExecutive.CurrentDSASMExec; core.CurrentExecutive.CurrentDSASMExec = interpreter.runtime; } // Assert for the block type activation.globs = core.DSExecutable.runtimeSymbols[core.RunningBlock].GetGlobalSize(); // Params formalParameters.Reverse(); for (int i = 0; i < formalParameters.Count; i++) { interpreter.Push(formalParameters[i]); } ProtoCore.DSASM.StackValue svThisPtr = stackFrame.GetAt(DSASM.StackFrame.AbsoluteIndex.kThisPtr); ProtoCore.DSASM.StackValue svBlockDecl = stackFrame.GetAt(DSASM.StackFrame.AbsoluteIndex.kFunctionBlock); // Jun: Make sure we have no empty or unaligned frame data Validity.Assert(DSASM.StackFrame.kStackFrameSize == stackFrame.Frame.Length); // Setup the stack frame data //int thisPtr = (int)stackFrame.GetAt(DSASM.StackFrame.AbsoluteIndex.kThisPtr).opdata; int ci = activation.classIndex; int fi = activation.funcIndex; int returnAddr = (int)stackFrame.GetAt(DSASM.StackFrame.AbsoluteIndex.kReturnAddress).opdata; int blockDecl = (int)svBlockDecl.opdata; int blockCaller = (int)stackFrame.GetAt(DSASM.StackFrame.AbsoluteIndex.kFunctionCallerBlock).opdata; int framePointer = core.Rmem.FramePointer; int locals = activation.locals; // Update the running block to tell the execution engine which set of instruction to execute // TODO(Jun/Jiong): Considering store the orig block id to stack frame int origRunningBlock = core.RunningBlock; core.RunningBlock = (int)svBlockDecl.opdata; // Set SX register interpreter.runtime.SX = svBlockDecl; DSASM.StackFrameType callerType = (DSASM.StackFrameType)stackFrame.GetAt(DSASM.StackFrame.AbsoluteIndex.kCallerStackFrameType).opdata; List <ProtoCore.DSASM.StackValue> registers = new List <DSASM.StackValue>(); ProtoCore.DSASM.StackValue svCallConvention; bool isDispose = procedureNode.name.Equals(ProtoCore.DSDefinitions.Kw.kw_Dispose); bool explicitCall = !c.IsReplicating && !c.IsImplicitCall && !isDispose; if (explicitCall) { svCallConvention = ProtoCore.DSASM.StackUtils.BuildNode(ProtoCore.DSASM.AddressType.CallingConvention, (long)ProtoCore.DSASM.CallingConvention.CallType.kExplicit); } else { svCallConvention = ProtoCore.DSASM.StackUtils.BuildNode(ProtoCore.DSASM.AddressType.CallingConvention, (long)ProtoCore.DSASM.CallingConvention.CallType.kImplicit); } stackFrame.SetAt(DSASM.StackFrame.AbsoluteIndex.kRegisterTX, svCallConvention); interpreter.runtime.TX = svCallConvention; // Set SX register stackFrame.SetAt(DSASM.StackFrame.AbsoluteIndex.kRegisterSX, svBlockDecl); interpreter.runtime.SX = svBlockDecl; // TODO Jun: // The stackframe carries the current set of registers // Determine if this can be done even for the non explicit call implementation registers.AddRange(stackFrame.GetRegisters()); // Comment Jun: the depth is always 0 for a function call as we are reseting this for each function call // This is only incremented for every language block bounce int depth = (int)stackFrame.GetAt(DSASM.StackFrame.AbsoluteIndex.kStackFrameDepth).opdata; DSASM.StackFrameType type = (DSASM.StackFrameType)stackFrame.GetAt(DSASM.StackFrame.AbsoluteIndex.kStackFrameType).opdata; Validity.Assert(depth == 0); Validity.Assert(type == DSASM.StackFrameType.kTypeFunction); core.Rmem.PushStackFrame(svThisPtr, ci, fi, returnAddr, blockDecl, blockCaller, callerType, type, depth, framePointer, registers, locals); ProtoCore.DSASM.StackValue svRet; if (explicitCall) { svRet = ProtoCore.DSASM.StackUtils.BuildNode(DSASM.AddressType.ExplicitCall, activation.pc); } else { if (core.ExecMode != DSASM.InterpreterMode.kExpressionInterpreter && core.Options.IDEDebugMode) { svRet = interpreter.Run(core.Breakpoints, core.RunningBlock, activation.pc, Language.kInvalid); } else { svRet = interpreter.Run(core.RunningBlock, activation.pc, Language.kInvalid); } core.RunningBlock = origRunningBlock; } if (core.CurrentExecutive != null) { core.CurrentExecutive.CurrentDSASMExec = oldDSASMExec; } return(svRet); //DSASM.Mirror.ExecutionMirror.Unpack(svRet, core.heap, core); }