static AsyncMethodDecompiler() { var type = typeof(AsyncVoidMethodBuilder); var aoc1 = type.GetMethod("AwaitOnCompleted"); var aoc2 = type.GetMethod("AwaitUnsafeOnCompleted"); var rwc = new AwaitOnCompletedRewriter(); AttributeInjector.Inject(aoc1, rwc); AttributeInjector.Inject(aoc2, rwc); var sr = type.GetMethod("SetResult"); var rwsr = new SetResultRewriter(); AttributeInjector.Inject(sr, rwsr); var se = type.GetMethod("SetException"); var serw = new SetExceptionRewriter(); AttributeInjector.Inject(se, serw); type = typeof(AsyncTaskMethodBuilder); aoc1 = type.GetMethod("AwaitOnCompleted"); aoc2 = type.GetMethod("AwaitUnsafeOnCompleted"); AttributeInjector.Inject(aoc1, rwc); AttributeInjector.Inject(aoc2, rwc); sr = type.GetMethod("SetResult"); AttributeInjector.Inject(sr, rwsr); se = type.GetMethod("SetException"); AttributeInjector.Inject(se, serw); var tarwc = new TaskAwaiterAwaitOnCompletedRewriter(); type = typeof(TaskAwaiter); AttributeInjector.Inject(type.GetMethod("get_IsCompleted"), new RewriteIsCompleted(), true); AttributeInjector.Inject(type.GetMethod("OnCompleted"), tarwc, true); AttributeInjector.Inject(type.GetMethod("UnsafeOnCompleted"), tarwc, true); AttributeInjector.Inject(type.GetMethod("GetResult"), new RewriteGetResult(), true); type = typeof(TaskAwaiter<>); AttributeInjector.Inject(type.GetMethod("get_IsCompleted"), new RewriteIsCompleted(), true); AttributeInjector.Inject(type.GetMethod("OnCompleted"), tarwc, true); AttributeInjector.Inject(type.GetMethod("UnsafeOnCompleted"), tarwc, true); AttributeInjector.Inject(type.GetMethod("GetResult"), new RewriteGetResult(), true); AttributeInjector.Inject(typeof(TaskAwaiter), new MapToIntrinsicType(Meta.EIntrinsicTypes.IllegalRuntimeType)); AttributeInjector.Inject(typeof(TaskAwaiter<>), new MapToIntrinsicType(Meta.EIntrinsicTypes.IllegalRuntimeType)); AttributeInjector.Inject(typeof(Task), new MapToIntrinsicType(Meta.EIntrinsicTypes.IllegalRuntimeType)); AttributeInjector.Inject(typeof(Task<>), new MapToIntrinsicType(Meta.EIntrinsicTypes.IllegalRuntimeType)); }
private void InjectAttributes(string prefix) { var fsmType = _code.AsyncMethod.GetStateMachineType(); _fsmInstance = Activator.CreateInstance(fsmType); AttributeInjector.Inject(fsmType, new HideDeclaration()); var thisField = fsmType .GetFields(BindingFlags.Public | BindingFlags.Instance) .Where(f => f.Name.Contains("this") && f.FieldType.Equals(_code.AsyncMethod.DeclaringType)) .FirstOrDefault(); if (thisField != null) { AttributeInjector.Inject(thisField, new StaticEvaluation()); thisField.SetValue(_fsmInstance, _instance); } var stateField = fsmType .GetFields(BindingFlags.Public | BindingFlags.Instance) .Where(f => f.Name.Contains("state") && f.FieldType.Equals(typeof(int))) .FirstOrDefault(); if (stateField != null) { AttributeInjector.Inject(stateField, new StateAccessRewriter()); } var awaiterFields = fsmType .GetFields(BindingFlags.NonPublic | BindingFlags.Instance) .Where(f => f.Name.Contains("$awaiter")); foreach (var awaiterField in awaiterFields) { AttributeInjector.Inject(awaiterField, new AwaiterAccessRewriter()); } _locFields = new Dictionary<string, Variable>(); _declared = new HashSet<Variable>(); _tasks = new Dictionary<string, object>(); var fields = fsmType.GetFields(); var lfar = new LocalFieldAccessRewriter(); var afar = new ArgFieldAccessRewriter(); var tar = new TaskAccessRewriter(); var argNames = _code.AsyncMethod .GetParameters() .Select(p => p.Name) .ToArray(); foreach (var field in fields) { var name = field.Name; bool isTask = false; if (field.FieldType.IsGenericType && field.FieldType.GetGenericTypeDefinition().Equals(typeof(Task<>))) { // it is a task variable AttributeInjector.Inject(field, tar); AttributeInjector.Inject(field.FieldType, new MapToIntrinsicType(Meta.EIntrinsicTypes.IllegalRuntimeType)); AttributeInjector.Inject(field.FieldType, new HideDeclaration()); isTask = true; } if (field.FieldType.IsGenericType && field.FieldType.GetGenericTypeDefinition().Equals(typeof(AsyncTaskMethodBuilder<>))) { var builderType = field.FieldType; var aoc1 = builderType.GetMethod("AwaitOnCompleted"); var aoc2 = builderType.GetMethod("AwaitUnsafeOnCompleted"); var rwc = new AwaitOnCompletedRewriter(); AttributeInjector.Inject(aoc1, rwc); AttributeInjector.Inject(aoc2, rwc); var sr = builderType.GetMethod("SetResult"); var rwsr = new SetResultRewriter(); AttributeInjector.Inject(sr, rwsr); var se = builderType.GetMethod("SetException"); var serw = new SetExceptionRewriter(); AttributeInjector.Inject(se, serw); } int pindex = Array.IndexOf(argNames, name); if (pindex >= 0) { field.SetValue(_fsmInstance, _arguments[pindex]); if (isTask) { var task = _arguments[pindex]; var lr = LiteralReference.CreateConstant(task); _tasks[field.Name] = new StackElement(lr, task, EVariability.Constant); } else { AttributeInjector.Inject(field, afar); } continue; } if (isTask) continue; int beg = name.IndexOf('<'); int end = name.LastIndexOf('>'); if (beg == -1 || end == -1 || (end - beg) <= 1) continue; var locName = prefix + name.Substring(beg + 1, end - beg - 1); var v = new Variable(field.FieldType) { Name = locName }; _locFields[field.Name] = v; AttributeInjector.Inject(field, lfar); } foreach (var local in _code.Method.GetMethodBody().LocalVariables) { var locType = local.LocalType; if (locType.IsGenericType && locType.GetGenericTypeDefinition().Equals(typeof(TaskAwaiter<>))) { AttributeInjector.Inject(locType, new HideDeclaration()); } } }
private CoFSM DecompileToCoFSM(string prefix) { ImplStyle = EAsyncImplStyle.FSM; InjectAttributes(prefix); InitializeCFGs(); CoFSM cofsm = new CoFSM(); var args = _code.AsyncMethod.GetParameters(); cofsm.Arguments = new Variable[args.Length]; _argFields = new Dictionary<string, Variable>(); for (int i = 0; i < args.Length; i++) { string name = prefix + "_" + args[i].Name; var argv = new Variable(TypeDescriptor.GetTypeOf(_arguments[i])) { Name = name }; _argFields[args[i].Name] = argv; cofsm.Arguments[i] = argv; } int numILStates = _stateCFGs.Length; var mym = _code as MethodDescriptor; cofsm.Method = mym; cofsm.Dependencies = new HashSet<Task>(); // Create result variable and done flag cofsm.DoneVar = new Variable(typeof(bool)) { Name = prefix + "_$done" }; if (_code.AsyncMethod.ReturnType.IsGenericType && _code.AsyncMethod.ReturnType.GetGenericTypeDefinition().Equals(typeof(Task<>))) { var resultType = _code.AsyncMethod.ReturnType.GetGenericArguments()[0]; if (!resultType.Equals(typeof(void))) { cofsm.ResultVar = new Variable(resultType) { Name = prefix + "_$result" }; var builderType = typeof(AsyncTaskMethodBuilder<>).MakeGenericType(resultType); AttributeInjector.Inject(builderType, new MapToIntrinsicType(Meta.EIntrinsicTypes.IllegalRuntimeType)); var aoc1 = builderType.GetMethod("AwaitOnCompleted"); var aoc2 = builderType.GetMethod("AwaitUnsafeOnCompleted"); var rwc = new AwaitOnCompletedRewriter(); AttributeInjector.Inject(aoc1, rwc); AttributeInjector.Inject(aoc2, rwc); var sr = builderType.GetMethod("SetResult"); var rwsr = new SetResultRewriter(); AttributeInjector.Inject(sr, rwsr); var se = builderType.GetMethod("SetException"); var serw = new SetExceptionRewriter(); AttributeInjector.Inject(se, serw); AttributeInjector.Inject(builderType, new HideDeclaration()); var awaiterType = typeof(TaskAwaiter<>).MakeGenericType(resultType); AttributeInjector.Inject(awaiterType, new MapToIntrinsicType(Meta.EIntrinsicTypes.IllegalRuntimeType)); AttributeInjector.Inject(awaiterType.GetMethod("get_IsCompleted"), new RewriteIsCompleted()); AttributeInjector.Inject(awaiterType.GetMethod("OnCompleted"), new AwaitOnCompletedRewriter()); AttributeInjector.Inject(awaiterType.GetMethod("UnsafeOnCompleted"), new AwaitOnCompletedRewriter()); AttributeInjector.Inject(awaiterType.GetMethod("GetResult"), new RewriteGetResult()); AttributeInjector.Inject(awaiterType, new HideDeclaration()); } } // Decompile state handlers _stateInfos = new Dictionary<StateInfo, StateInfo>(); var decomp = new MSILDecompiler(_code, _stateCFGs[0], _fsmInstance); _curTempl = decomp.Template; _curTempl.AddAttribute(this); _curTempl.DisallowReturnStatements = true; _curTempl.DisallowConditionals = true; _curTempl.DisallowLoops = true; var lvState = _curTempl.ExportLocalVariableState(); var startSI = new StateInfo(-1); foreach (var kvp in _locFields) startSI.LVState[kvp.Key] = kvp.Value.Type.GetSampleInstance(ETypeCreationOptions.ForceCreation); _stateInfos[startSI] = startSI; _curSI = startSI; var stateList = new List<StateInfo>(); stateList.Add(startSI); _stateQ = new Queue<StateInfo>(); _curCoFSM = cofsm; startSI.Result = decomp.Decompile(); while (_stateQ.Any()) { var nextSI = _stateQ.Dequeue(); _curSI = nextSI.Fork(nextSI.ILState); decomp = new MSILDecompiler(_code, _stateCFGs[nextSI.ILState + 1], _fsmInstance); _curTempl = decomp.Template; _curTempl.AddAttribute(this); _curTempl.DisallowReturnStatements = true; _curTempl.DisallowConditionals = true; _curTempl.DisallowLoops = true; _curSI.Result = decomp.Decompile(); stateList.Add(_curSI); _stateInfos[_curSI] = _curSI; } // Create state active variables cofsm.StateActiveVars = new List<Variable>(); int j = 0; for (int i = 0; i < stateList.Count; i++) { if (stateList[i].HasWaitState) { cofsm.StateActiveVars.Add(new Variable(typeof(bool)) { Name = prefix + "_$waitStateActive" + i }); stateList[i].WaitStateValue = j++; } cofsm.StateActiveVars.Add(new Variable(typeof(bool)) { Name = prefix + "_$stateActive" + i }); stateList[i].StateValue = j++; } int numStates = j; // Replace ProceedWithState calls with actual states var states = new Statement[numStates]; j = 0; for (int i = 0; i < stateList.Count; i++) { if (stateList[i].HasWaitState) { var wsb = new DefaultAlgorithmBuilder(); ImplementJoin(stateList[i].JP, wsb, stateList[i]); //wsb.Call(stateList[i].JoinSpec, new Expression[0]); var join = wsb.Complete(); states[j++] = join.Body; } states[j++] = stateList[i].Result.Decompiled.Body; } for (j = 0; j < states.Length; j++) { var orgBody = states[j]; var xform = new CoStateAssigner(this, cofsm.StateActiveVars, orgBody, j); var state = xform.GetAlgorithm(); states[j] = state.Body; } var calledMethods = stateList .SelectMany(b => b.Result.CalledMethods) .Distinct() .ToList(); var calledSyncMethods = calledMethods .Where(mci => !mci.Method.IsAsync()) .ToList(); cofsm.CalledMethods = calledSyncMethods; // State handlers var alg = new DefaultAlgorithmBuilder(); alg.Store(cofsm.DoneVar, LiteralReference.CreateConstant(false)); for (int i = states.Length - 1; i >= 1; i--) { var lrsa = (LiteralReference)cofsm.StateActiveVars[i]; alg.If(lrsa); alg.InlineCall(states[i]); alg.EndIf(); } var handlerAlg = alg.Complete(); cofsm.HandlerBody = handlerAlg.Body; alg = new DefaultAlgorithmBuilder(); alg.Store(cofsm.DoneVar, LiteralReference.CreateConstant(false)); alg.InlineCall(states[0]); cofsm.InitialHandler = alg.Complete().Body; return cofsm; }