public bool Resolve(MethodStateMachine methodSM) { //Pop away finished method _callStack.Pop(); //Take its return value if needed if (methodSM.Context.ReturnsValue && _callStack.Count != 0) { _callStack.Peek().TakeMethodReturnValue(methodSM.Context.EvalStack); } if (methodSM.MethodDesc.IsEntryPoint && methodSM.MethodDesc.ReturnType != null) { EntryPointRet(methodSM.Context.EvalStack.Peek(), methodSM.MethodDesc.ReturnType); } //Find finally block. If exists, jump to its offset and continue execution. if not, break if (methodSM.FinalliesBeforeReturn()) { methodSM.State.ExecutionInterruption = ExecutionInterruption.None; return(true); } else { return(false); } }
public bool Resolve(MethodStateMachine methodSM) { //Create an execution model for calling method var cmExec = _methodStateMachineFactory.Create(methodSM.State.CallMethod); cmExec.Caller = methodSM; if (cmExec == null) { throw new Exception("Method not found"); } //Fill calling method's arguments if any if (cmExec.MethodDesc.TakesArguments) { cmExec.SetMethodArguments(methodSM.Context.EvalStack); } //Add calling method to the call stack _callStack.Push(cmExec); //Reset the flow methodSM.State.ExecutionInterruption = ExecutionInterruption.None; methodSM.State.CallMethod = null; return(false); }
public static MethodStateMachine CreateForMethod(MethodDesc methodDescription, IGCHeap gcHeap, ITypesHeap typesHeap, ITypeLoader typeLoader, IILOperationSet operationSet) { MethodStateMachine execModel = new MethodStateMachine() { _operationSet = operationSet, MethodDesc = methodDescription, Context = ILTool.Kernel.MethodContext.CreateForMethod(methodDescription, gcHeap, typesHeap, typeLoader), State = new MethodState() }; return(execModel); }
public void Start() { try { MethodDesc entryPoint = _compiledModel.Methods.Values.Where(d => d.IsEntryPoint).SingleOrDefault(); if (entryPoint == null) { throw new InvalidOperationException("Entry point not found"); } MethodStateMachine entryPointExecModel = _methodStateMachineFactory.Create(entryPoint); _callStack.Push(entryPointExecModel); ProcessCallStack(); } catch (Exception ex) { throw; } }
private void ProcessCallStack() { while (_callStack.Count != 0) { MethodStateMachine methodSM = _callStack.Peek(); while (true) { methodSM.ExecInstructions(); if (_interruptionResolvers[methodSM.State.ExecutionInterruption].Resolve(methodSM)) { continue; } else { break; } } } }
public bool Resolve(MethodStateMachine methodSM) { var exInfo = methodSM.State.ExeptionInfo; var currMethod = methodSM; EHTryEntity catchHandler = null; do { catchHandler = currMethod.ThrowLogicForMethod(exInfo); if (catchHandler != null) { break; } //Continue to search an appropriate catch handler in the method one hierarchy upper currMethod = currMethod.Caller; }while (currMethod != null); methodSM.State.ExecutionInterruption = ExecutionInterruption.None; methodSM.State.ExeptionInfo = null; return(true); }
public MethodStateMachine Create(MethodDesc methodDesc) { MethodStateMachine entryPointExecModel = MethodStateMachine.CreateForMethod(methodDesc, _gcHeap, _typesHeap, _typeLoader, _ilOperationSet); return(entryPointExecModel); }